returns array of all the position related events with extra info and filters
@memberof OrientationCollector
@returns {array} event deatails in format [name, position, extraInfo]
427064
function getEvents(duration){

    if (positionCallback == null){
        return [];
    }

    currentPosition = positionCallback();

    if (!currentPosition){

        return [];
        
    }

    const extra = {
        'ik': ['Time'],
        'iv': [utils.getDataPointDuration(duration)],
        'fk': [],
        'fv': []
    };

    return [['vadrPosition', currentPosition, extra]];

}
695791
function() {
      var sortedInputEvents = this.getSortedInputEvents();
      var protoIRs = this.findProtoIRs(sortedInputEvents);
      protoIRs = this.postProcessProtoIRs(protoIRs);
      this.checkAllInputEventsHandled(sortedInputEvents, protoIRs);

      var irs = [];
      var model = this.model;
      protoIRs.forEach(function(protoIR) {
        var ir = protoIR.createInteractionRecord(model);
        if (ir)
          irs.push(ir);
      });
      return irs;
    }
1123202
function(e) {
		var tgt = YAHOO.util.Event.getTarget(e);
		var tgtPos = [tgt.offsetLeft, tgt.offsetTop];
		return [tgtPos[0]+e.layerX, tgtPos[1]+e.layerY];
   }
15496
function getOriginalPositionFor(lineNumber, columnNumber, moduleIds, context) {
  const position = getOriginalPositionDetailsFor(
    lineNumber,
    columnNumber,
    moduleIds,
    context,
  );
  if (position.functionName) {
    position.name = position.functionName;
  }
  delete position.functionName;
  return position;
}
225764
function() {
      var debugString = this.irType + '(';
      debugString += parseInt(this.start) + ' ';
      debugString += parseInt(this.end);
      this.associatedEvents.forEach(function(event) {
        debugString += ' ' + event.typeName;
      });
      return debugString + ')';
    }
16498
function getPositionFromOffset(el, of) {
  var offsetParent = getOffsetParent(el);
  var parentOf = getOffset(offsetParent);
  return {
    x: of.x - parentOf.x,
    y: of.y - parentOf.y
  };
}
157008
public static function getEventList()
    {
        return array(
            self::EVENT_TYPE_CREATIVEVIEW,
            self::EVENT_TYPE_START,
            self::EVENT_TYPE_FIRSTQUARTILE,
            self::EVENT_TYPE_MIDPOINT,
            self::EVENT_TYPE_THIRDQUARTILE,
            self::EVENT_TYPE_COMPLETE,
            self::EVENT_TYPE_MUTE,
            self::EVENT_TYPE_UNMUTE,
            self::EVENT_TYPE_PAUSE,
            self::EVENT_TYPE_REWIND,
            self::EVENT_TYPE_RESUME,
            self::EVENT_TYPE_FULLSCREEN,
            self::EVENT_TYPE_EXITFULLSCREEN,
            self::EVENT_TYPE_EXPAND,
            self::EVENT_TYPE_COLLAPSE,
            self::EVENT_TYPE_ACCEPTINVITATIONLINEAR,
            self::EVENT_TYPE_CLOSELINEAR,
            self::EVENT_TYPE_SKIP,
            self::EVENT_TYPE_PROGRESS,
        );
    }
381078
function getCoords(ev) {
          var x, y, w, h, el;

          // ignore browsers without pageX for now
          if (ev.pageX === null) return;

          x = ev.pageX;
          y = ev.pageY;
          el = self.element;

          // should probably check offsetParent
          // but this is more portable
          while (el !== document.documentElement) {
              x -= el.offsetLeft;
              y -= el.offsetTop;
              el = el.parentNode;
          }

          // convert to cols/rows
          w = self.element.clientWidth;
          h = self.element.clientHeight;
          x = ((x / w) * self.cols) | 0;
          y = ((y / h) * self.rows) | 0;

          // be sure to avoid sending
          // bad positions to the program
          if (x < 0) x = 0;
          if (x > self.cols) x = self.cols;
          if (y < 0) y = 0;
          if (y > self.rows) y = self.rows;

          // xterm sends raw bytes and
          // starts at 32 (SP) for each.
          x += 32;
          y += 32;

          return {
              x: x,
              y: y,
              down: ev.type === 'mousedown',
              up: ev.type === 'mouseup',
              wheel: ev.type === wheelEvent,
              move: ev.type === 'mousemove'
          };
      }
983212
private function returnGlobalEvents()
	{
		static $returnedEvents;
		$out = "";

		if (!isset($returnedEvents)) {
			$returnedEvents = array();
		}

		if (!empty($this->globalEvents)) {
			foreach ($this->globalEvents as $eventName => $handlers) {
				foreach ($handlers as $handler => $code) {
					if (!isset($returnedEvents[$eventName])) {
						$returnedEvents[$eventName] = array();
					}
					// Return only new events
					if (!in_array($code, $returnedEvents[$eventName])) {
						$out .= ($code ? "\n" : "") . "CKEDITOR.on('". $eventName ."', $code);";
						$returnedEvents[$eventName][] = $code;
					}
				}
			}
		}

		return $out;
	}
653653
function () {
            var translateFraction = this.translationFraction;
            var x = this.startPosition.x;
            var y = this.startPosition.y;
            if (this.endPosition.x) {
                x = this.startPosition.x + translateFraction * (this.endPosition.x - this.startPosition.x);
            }
            if (this.endPosition.y) {
                y = this.startPosition.y + translateFraction * (this.endPosition.y - this.startPosition.y);
            }
            return { x: x, y: y };
        }
1348361
function GetOnEvent(title) {
    var retList, i;

    retList = [];
    for(i = 0 ; i < onList.length ; i++) {
        if(onList[i].event.toString() === title.toString()) {
            retList.push(onList[i].callback);
        }
    }
    return retList;
}
393762
public LogEvent[] getLogEvents() {
        if (mLogEvents == null) {
            return new LogEvent[0];
        }
        else {
            LogEvent[] events = new LogEvent[mLogEvents.size()];
            return (LogEvent[])mLogEvents.toArray(events);
        }
    }
139848
function getAllNearPositions(position) {
    return [[-1, -1], [0, -1], [1, -1], [-1, 0], [1, 0], [-1, 1], [0, 1], [1, 1] // Below positions
    ].map(function (toAdd) {
        return {
            x: position.x + toAdd[0],
            y: position.y + toAdd[1]
        };
    });
}
1074584
function() {
      var behaviorEvents = _.result(this, 'events');
      var viewEvents = this.view.events;

      if (!viewEvents) {
        if (!behaviorEvents) {
          return;
        } else {
          viewEvents = {};
        }
      }

      var namespacedEvents = this.__namespaceEvents(behaviorEvents);
      var boundBehaviorEvents = this.__bindEventCallbacksToBehavior(namespacedEvents);

      if (_.isFunction(viewEvents)) {
        this.view.events = _.wrap(_.bind(viewEvents, this.view), function(viewEventFunction) {
          return _.extend(boundBehaviorEvents, viewEventFunction());
        });
      } else if (_.isObject(viewEvents)) {
        this.view.events = _.extend(boundBehaviorEvents, viewEvents);
      }
    }
684167
function initEvents() {
        var bind = _this.h.addEventListener;
        var eventTarget = params.eventTarget === 'wrapper' ? _this.wrapper : _this.container;
        //Touch Events
        if (! (_this.browser.ie10 || _this.browser.ie11)) {
            if (_this.support.touch) {
                bind(eventTarget, 'touchstart', onTouchStart);
                bind(eventTarget, 'touchmove', onTouchMove);
                bind(eventTarget, 'touchend', onTouchEnd);
            }
            if (params.simulateTouch) {
                bind(eventTarget, 'mousedown', onTouchStart);
                bind(document, 'mousemove', onTouchMove);
                bind(document, 'mouseup', onTouchEnd);
            }
        }
        else {
            bind(eventTarget, _this.touchEvents.touchStart, onTouchStart);
            bind(document, _this.touchEvents.touchMove, onTouchMove);
            bind(document, _this.touchEvents.touchEnd, onTouchEnd);
        }

        //Resize Event
        if (params.autoResize) {
            bind(window, 'resize', _this.resizeFix);
        }
        //Slide Events
        addSlideEvents();
        //Mousewheel
        _this._wheelEvent = false;
        if (params.mousewheelControl) {
            if (document.onmousewheel !== undefined) {
                _this._wheelEvent = 'mousewheel';
            }
            if (!_this._wheelEvent) {
                try {
                    new WheelEvent('wheel');
                    _this._wheelEvent = 'wheel';
                } catch (e) {}
            }
            if (!_this._wheelEvent) {
                _this._wheelEvent = 'DOMMouseScroll';
            }
            if (_this._wheelEvent) {
                bind(_this.container, _this._wheelEvent, handleMousewheel);
            }
        }

        //Keyboard
        function _loadImage(src) {
            var image = new Image();
            image.onload = function () {
                if (typeof _this === 'undefined' || _this === null) return;
                if (_this.imagesLoaded !== undefined) _this.imagesLoaded++;
                if (_this.imagesLoaded === _this.imagesToLoad.length) {
                    _this.reInit();
                    if (params.onImagesReady) _this.fireCallback(params.onImagesReady, _this);
                }
            };
            image.src = src;
        }

        if (params.keyboardControl) {
            bind(document, 'keydown', handleKeyboardKeys);
        }
        if (params.updateOnImagesReady) {
            _this.imagesToLoad = $$('img', _this.container);

            for (var i = 0; i < _this.imagesToLoad.length; i++) {
                _loadImage(_this.imagesToLoad[i].getAttribute('src'));
            }
        }
    }
466918
public List<EventDefinitionType<PortletDescriptor>> getAllEventDefinition()
   {
      List<EventDefinitionType<PortletDescriptor>> list = new ArrayList<EventDefinitionType<PortletDescriptor>>();
      List<Node> nodeList = model.get("event-definition");
      for(Node node: nodeList)
      {
         EventDefinitionType<PortletDescriptor>  type = new EventDefinitionTypeImpl<PortletDescriptor>(this, "event-definition", model, node);
         list.add(type);
      }
      return list;
   }
891872
def events(self):
        
        if not self.event_reflector:
            return []

        events = []
        for event in self.event_reflector.events:
            if event.involved_object.name != self.pod_name:
                # only consider events for my pod name
                continue

            if self._last_event and event.metadata.uid == self._last_event:
                # saw last_event marker, ignore any previous events
                # and only consider future events
                # only include events *after* our _last_event marker
                events = []
            else:
                events.append(event)
        return events