Trigger rendering of the tooltip after a slight delay, less twitchy more
user friendly.

@param {Event} event
@api public
492869
function create(event) {
    if (!this.trigger(event)) return;
    if ('preventDefault' in event) event.preventDefault();
    if (this.trigger(event, 'click') && this.remove(event)) return;

    //
    // Create a new tooltip, but make sure to destroy remaining ones before.
    //
    this.timer = setTimeout(function execute() {
      this.render(event);
    }.bind(this), this.delay);
  }
984392
function(delay) {
			if(this.isTurnedOff){
				return;
			}
			if (this.isShowing()) { //$NON-NLS-0$
				return;
			}
			if (this._timeout) {
				window.clearTimeout(this._timeout);
				this._timeout = null;
			}
			var showDelay = delay !== undefined ? delay : this._showDelay;
			if (showDelay) {
				this._timeout = window.setTimeout(this._showImmediately.bind(this), showDelay);	
			} else {
				this._showImmediately();
			}
		}
339807
function () {
            // Remove the other tooltips
            // if it was requested.
            if (this.reset !== false)
                this.resetTooltip();
            //  elements
            var container = $("<div>").attr({
                "class": "error-label-container"
            }).appendTo(this.settings.element);
            var arrow = $("<div>").attr({
                "class": "error-label-arrow-" + this.settings.arrow
            }).appendTo(container);
            var label = $("<div>").attr({
                "class": "error-label"
            }).html(this.settings.label).appendTo(container);
            // Set the red glow around the input
            this.settings.element.addClass("tooltip-active");
            // If the fadeout option is set, then
            // fade it out after the given time.
            // Otherwise, make it clickable to let
            // the user remove it.
            if ($.isNumeric(this.settings.fadeOut))
                container.delay(this.settings.fadeOut).fadeOut("slow");
            label.click(function () {
                $(this).parent().remove();
            });
        }
785415
function (event, template) {
            this.moduleCtrl.displayHighlight(template.templateCtxt.getContainerDiv());
            this.data.overModuleCtrl = template.moduleCtrl;
            this.mouseOver(event);
            this._refreshModulesDisplay();
            // prevent propagation
            event.stopPropagation();
        }
428373
function eventTap ( event ) {

            // The tap event shouldn't propagate up
            event.stopPropagation();

            var proposal = calcPointToPercentage(event.calcPoint);
            var handleNumber = getClosestHandle(proposal);

            // Tackle the case that all handles are 'disabled'.
            if ( handleNumber === false ) {
                return false;
            }

            // Flag the slider as it is now in a transitional state.
            // Transition takes a configurable amount of ms (default 300). Re-enable the slider after that.
            if ( !options.events.snap ) {
                addClassFor(scope_Target, options.cssClasses.tap, options.animationDuration);
            }

            setHandle(handleNumber, proposal, true, true);

            setZindex();

            fireEvent('slide', handleNumber, true);
            fireEvent('set', handleNumber, true);
            fireEvent('change', handleNumber, true);
            fireEvent('update', handleNumber, true);

            if ( options.events.snap ) {
                eventStart(event, { handleNumbers: [handleNumber] });
            }
        }
554358
def showEvent(self, event):
        
        super(XMenu, self).showEvent(event)
        
        self.adjustSize()
        self.adjustMinimumWidth()
        self.rebuildButtons()
675371
protected void __triggerRenderEvent(IEvent<Void, ITemplate> event, RythmEngine engine) {
        event.trigger(engine, this);
    }
764933
function (event, module) {
            this.data.overTemplates = module.outerTemplateCtxts;
            this.mouseOver(event);
            this._refreshTemplatesDisplay();
            // prevent propagation
            event.stopPropagation();
        }
617708
function (element, options) {
    this.type       =
    this.options    =
    this.enabled    =
    this.timeout    =
    this.hoverState =
    this.$element   = null

    this.init('tooltip', element, options)
  }
975193
function (event) {
            if (event.event.name == "ContextualTargetFound") {
                var templateCtxt = event.event.templateCtxt;
                // NO NEED TO REFRESH -> displaying the context menu does it already
                this._selectFromTemplateCtxt(templateCtxt);
            }
        }
1043110
function(hideDelay) {
			this._showByKB = undefined;
			
			if (this._timeout) {
				window.clearTimeout(this._timeout);
				this._timeout = null;
			}
			if (!this.isShowing()) { //$NON-NLS-0$
				return;
			}
			if (hideDelay === undefined) {
				hideDelay = this._hideDelay;
			}
			var self = this;
			this._timeout = window.setTimeout(function() {
				self._tip.classList.remove("tooltipShowing"); //$NON-NLS-0$
				self._tip.removeAttribute("style"); //$NON-NLS-0$
				if (self._afterHiding) {
					self._afterHiding();
				}
			}, hideDelay);
		}
574972
function Tooltip(el, options) {
      _classCallCheck(this, Tooltip);

      var _this26 = _possibleConstructorReturn(this, (Tooltip.__proto__ || Object.getPrototypeOf(Tooltip)).call(this, Tooltip, el, options));

      _this26.el.M_Tooltip = _this26;
      _this26.options = $.extend({}, Tooltip.defaults, options);

      _this26.isOpen = false;
      _this26.isHovered = false;
      _this26.isFocused = false;
      _this26._appendTooltipEl();
      _this26._setupEventHandlers();
      return _this26;
    }
980823
function(event) {
        event = event || {};

        if (event.added) {
            this._renderSelectedItem(event.added);

            this._scrollToBottom();
        } else if (event.removed) {
            removeElement(this.$(getItemSelector(SELECTED_ITEM_SELECTOR, event.removed.id)));
        } else {
            this._forEachSelectedItem(removeElement);

            this._data.forEach(this._renderSelectedItem, this);

            this._updateInputWidth();
        }

        if (event.added || event.removed) {
            if (this.dropdown) {
                this.dropdown.showResults(this.filterResults(this.dropdown.results), {
                    hasMore: this.dropdown.hasMore
                });
            }

            if (!hasTouch) {
                this.focus();
            }
        }

        this.positionDropdown();

        this._updatePlaceholder();
    }
452085
def hoverLeaveEvent(self, event):
        
        if self._hoverSpot:
            if self._hoverSpot.hoverLeaveEvent(event):
                self.update()
        
        self._hoverSpot = None
        self._hovered = False
        
        super(XNode, self).setToolTip(self._toolTip)
        super(XNode, self).hoverLeaveEvent(event)
413887
function(e) {
      var tooltip = this.$(".ui-tooltip-top");
      var val = this.input.val();
      tooltip.fadeOut();
      if (this.tooltipTimeout) clearTimeout(this.tooltipTimeout);
      if (val == '' || val == this.input.attr('placeholder')) return;
      var show = function(){ tooltip.show().fadeIn(); };
      this.tooltipTimeout = _.delay(show, 1000);
    }
1290042
function (event) {
        // Default mouse behaviour should not be disabled here.
        // For example, page may needs to be slided.
        event = normalizeEvent(this.dom, event);

        // Mark touch, which is useful in distinguish touch and
        // mouse event in upper applicatoin.
        event.zrByTouch = true;

        this._lastTouchMoment = new Date();

        this.handler.processGesture(this, event, 'start');

        // In touch device, trigger `mousemove`(`mouseover`) should
        // be triggered, and must before `mousedown` triggered.
        domHandlers.mousemove.call(this, event);

        domHandlers.mousedown.call(this, event);

        setTouchTimer(this);
    }
46391
function (event, template) {
            // this.moduleCtrl.clearHighlight();
            this.data.overModuleCtrl = null;
            this.mouseOut(event);
            this._refreshModulesDisplay();
            // prevent propagation
            event.stopPropagation();
        }