not 'target' to the delegate container
499329
public void setup(@Observes EventContext<SetupContainer> setup) throws Exception {
        SetupContainer event = setup.getEvent();
        if (isChameleonContainer(event)) {
            initiateChameleon(event);
        }
        setup.proceed();
    }
884
protected void removeTargetListeners (Component comp)
    {
        comp.removeMouseListener(_targetListener);
        comp.removeMouseMotionListener(_targetListener);
        if (comp instanceof Container) { // again, always true for JComp...
            Container cont = (Container) comp;
            cont.removeContainerListener(_childListener);
            for (int ii=0, nn=cont.getComponentCount(); ii < nn; ii++) {
                removeTargetListeners(cont.getComponent(ii));
            }
        }
    }
381328
public void invokeTemplate(int line, String name, ITemplate caller, ITag.__ParameterList params, ITag.__Body body, ITag.__Body context, boolean ignoreNonExistsTag) {
        if (_nonExistsTags.contains(name)) return;

        Sandbox.enterSafeZone(secureCode);
        RythmEvents.ENTER_INVOKE_TEMPLATE.trigger(this, (TemplateBase) caller);
        try {
            // try tag registry first
            ITemplate t = _tags.get(name);
            if (null == t) {
                t = _templates.get(name);
            }
            if (null == t && S.isEqual(name, caller.__getName())) {
                // is calling self
                t = caller;
            }

            if (null == t) {
                // try imported path
                TemplateClass tc = caller.__getTemplateClass(true);
                if (null != tc.importPaths) {
                    for (String s : tc.importPaths) {
                        if (s.startsWith("java")) {
                            continue;
                        }
                        String name0 = s + "." + name;
                        t = _tags.get(name0);
                        if (null == t) t = _templates.get(name0);
                        if (null != t) break;
                    }
                }

                // try relative path
                if (null == t) {
                    String callerName = tc.getTagName();
                    int pos = -1;
                    if (null != callerName) pos = callerName.lastIndexOf(".");
                    if (-1 != pos) {
                        String name0 = callerName.substring(0, pos) + "." + name;
                        t = _tags.get(name0);
                        if (null == t) t = _templates.get(name0);
                    }
                }

                // try load the tag from resource
                if (null == t) {
                    tc = resourceManager().tryLoadTemplate(name, tc, caller.__curCodeType());
                    if (null != tc) t = _templates.get(tc.getTagName());
                    if (null == t) {
                        if (ignoreNonExistsTag) {
                            if (logger.isDebugEnabled()) {
                                logger.debug("cannot find tag: " + name);
                            }
                            _nonExistsTags.add(name);
                            if (isDevMode() && nonExistsTemplatesChecker == null) {
                                nonExistsTemplatesChecker = new NonExistsTemplatesChecker();
                            }
                            return;
                        } else {
                            throw new NullPointerException("cannot find tag: " + name);
                        }
                    }
                    t = t.__cloneMe(this, caller);
                }
            }

            if (!(t instanceof JavaTagBase)) {
                // try refresh the tag loaded from template file under tag root
                // note Java source tags are not reloaded here
                String cn = t.getClass().getName();
                TemplateClass tc0 = classes().getByClassName(cn);
                if (null == tc0) {
                    throw new NullPointerException(String.format("null tc0 found. t.class: %s, name: %s, caller.class: %s", cn, name, caller.getClass()));
                }
                t = tc0.asTemplate(caller, this);
            } else {
                t = t.__cloneMe(this, caller);
            }

            if (null != params) {
                if (t instanceof JavaTagBase) {
                    ((JavaTagBase) t).__setRenderArgs0(params);
                } else {
                    for (int i = 0; i < params.size(); ++i) {
                        ITag.__Parameter param = params.get(i);
                        if (null != param.name) t.__setRenderArg(param.name, param.value);
                        else t.__setRenderArg(i, param.value);
                    }
                }
            }
            if (null == body && null != params) {
                body = (ITag.__Body) params.getByName("__body");
                if (null == body) {
                    body = (ITag.__Body) params.getByName("_body");
                }
            }
            if (null != body) {
                t.__setRenderArg("__body", body);
                t.__setRenderArg("_body", body); // for compatibility
            }
            RythmEvents.ON_TAG_INVOCATION.trigger(this, F.T2((TemplateBase) caller, t));
            try {
                if (null != context) {
                    t.__setBodyContext(context);
                }
                t.__setSecureCode(secureCode).__call(line);
            } finally {
                RythmEvents.TAG_INVOKED.trigger(this, F.T2((TemplateBase) caller, t));
            }
        } finally {
            RythmEvents.EXIT_INVOKE_TEMPLATE.trigger(this, (TemplateBase) caller);
            Sandbox.leaveCurZone(secureCode);
        }
    }
921894
function (out) {
            // --------------------------------------------------- destructuring

            var cfg = this._cfg;
            var icon = cfg.icon;
            var tooltip = cfg.tooltip;
            var tabIndex = cfg.tabIndex;
            var waiAria = cfg.waiAria;
            var label = cfg.label;
            var role = cfg.role;

            var id = this._domId;
            var iconInfo = this._iconInfo;
            var extraAttributes = this.extraAttributes;

            // ------------------------------------------------------ processing

            var attributes = [];

            function addAttribute(key, value) {
                value = '' + value;
                value = ariaUtilsString.escapeForHTML(value, {attr: true});
                attributes.push(key + '="' + value + '"');

                attributes.push(subst('%1="%2"', key, value));
            }

            // delegationMarkup ------------------------------------------------

            var delegateManager = aria.utils.Delegate;
            var delegateId = this._delegateId;

            if (!delegateId) {
                delegateId = delegateManager.add({
                    fn : this.delegate,
                    scope : this
                });
                this._delegateId = delegateId;
            }

            var delegationMarkup = delegateManager.getMarkup(delegateId);

            // icon ------------------------------------------------------------

            addAttribute('id', id);


            var style = null;

            if (!iconInfo.spriteURL && icon) {
                var parts = icon.split(":");
                var skinclass = parts[0];
                var contentKey = parts[1];

                var classes = aria.widgets.AriaSkinInterface.getSkinObject("Icon", skinclass, true).content[contentKey];

                addAttribute('class', ['xWidget'].concat(classes).join(' '));
            } else {
                addAttribute('class', this._getIconClasses(iconInfo));
                if (tooltip != null && tooltip !== '') {
                    tooltip = addAttribute('title', tooltip);
                }
                attributes.push(delegationMarkup);

                style = this._getIconStyle(iconInfo);
            }

            if (tabIndex != null) {
                tabIndex = this._calculateTabIndex();
                addAttribute('tabindex', tabIndex);
            }

            if (waiAria && label) {
                addAttribute('aria-label', label);
            }

            if (waiAria && role) {
                addAttribute('role', role);
            }

            if (style) {
                addAttribute('style', style);
            }

            attributes.push(extraAttributes);

            attributes = attributes.join(' ');
            var markup = '<span ' + attributes + '></span>';

            // ---------------------------------------------------------- output

            out.write(markup);
        }
678010
function (domElt, id) {
            domElt.setAttribute(this.delegateExpando, id);

            // for iOS, refer to method getMarkup
            if (ariaCoreBrowser.isIOS) {
                if (domElt.onclick == null) {
                    domElt.onclick = Aria.empty;
                }
            }
        }
983288
function(storage, name, widget) {

		if (!(name in storage)) Lava.t("Trying to remove a global event target for nonexistent event");

		var index = storage[name].indexOf(widget);

		if (index !== -1) {

			storage[name].splice(index, 1);

		}

	}
568525
function () {
                var eventListeners = this._cfg.on, hasListeners = false, listArray;
                var delegateManager = ariaUtilsDelegate;
                var delegateFallbackEvents = [];

                for (var listener in eventListeners) {
                    if (eventListeners.hasOwnProperty(listener)) {
                        hasListeners = true;
                        if (!delegateManager.isDelegated(listener)) {
                            delegateFallbackEvents.push(listener);
                        }
                        listArray = eventListeners[listener];
                        if (!ariaUtilsType.isArray(listArray)) {
                            listArray = [listArray];
                        }
                        for (var i = 0, listCount = listArray.length; i < listCount; i++) {
                            listArray[i] = this.$normCallback.call(this._context._tpl, listArray[i]);
                        }
                        eventListeners[listener] = listArray;
                    }
                }

                if (hasListeners) {
                    this.__delegateId = delegateManager.add({
                        fn : this._delegate,
                        scope : this
                    });
                    this.__delegateFallbackEvents = delegateFallbackEvents;
                }
            }
1082146
public void eventCancelledByEventGateway(DelegateExecution execution) {
    Context.getCommandContext().getExecutionEntityManager().deleteExecutionAndRelatedData((ExecutionEntity) execution, 
        DeleteReason.EVENT_BASED_GATEWAY_CANCEL, false);
  }
99388
@Override
    public STRATEGYSTAGETYPE resolve(String... coordinates) throws IllegalArgumentException, ResolutionException {
        return delegate.resolve(coordinates);
    }
596903
private static Runnable rejectionPropagatingRunnable(
      final AbstractFuture<?> outputFuture,
      final Runnable delegateTask,
      final Executor delegateExecutor) {
    return new Runnable() {
      @Override public void run() {
        final AtomicBoolean thrownFromDelegate = new AtomicBoolean(true);
        try {
          delegateExecutor.execute(new Runnable() {
            @Override public void run() {
              thrownFromDelegate.set(false);
              delegateTask.run();
            }
          });
        } catch (RejectedExecutionException e) {
          if (thrownFromDelegate.get()) {
            // wrap exception?
            outputFuture.setException(e);
          }
          // otherwise it must have been thrown from a transitive call and the delegate runnable
          // should have handled it.
        }
      }
    };
  }
1134302
function(e) {
		// Find the control who maps to e.target, or the first control that maps to an ancestor of e.target.
		var c = this.findDispatchTarget(e.target) || this.findDefaultTarget(e);
		// Cache the original target
		e.dispatchTarget = c;
		// support pluggable features return true to abort immediately or set e.preventDispatch to avoid processing.
		for (var i=0, fn; (fn=this.features[i]); i++) {
			if (fn.call(this, e) === true) {
				return;
			}
		}
		if (c && !e.preventDispatch) {
			this.dispatchBubble(e, c);
		}
	}
153855
function delegate (root, filter, fn) {
  if (delegates[fn._dd]) {
    return delegates[fn._dd];
  }
  fn._dd = Date.now();
  delegates[fn._dd] = delegator;
  function delegator (e) {
    var el = e.target;
    while (el && el !== root) {
      if (api.matches(el, filter)) {
        fn.apply(this, arguments); return;
      }
      el = el.parentElement;
    }
  }
  return delegator;
}
446861
static void throwMissingVariable(ViewDataBinding binding, int bindingVariable, @LayoutRes int layoutRes) {
        Context context = binding.getRoot().getContext();
        Resources resources = context.getResources();
        String layoutName = resources.getResourceName(layoutRes);
        String bindingVariableName = DataBindingUtil.convertBrIdToString(bindingVariable);
        throw new IllegalStateException("Could not bind variable '" + bindingVariableName + "' in layout '" + layoutName + "'");
    }
1286012
function delegateHandler(evt, selector, handler) {
    const scopeSelector = `[${randomID}="${randomID}"] `;
    const splittedSelector = selector.split(',');

    let matching = '';

    for (let i = 0; i < splittedSelector.length; i++) {
        const sel = splittedSelector[i];
        matching += `${i === 0 ? '' : ','}${scopeSelector}${sel},${scopeSelector}${sel} *`;
    }


    this.setAttribute(randomID, randomID);

    if (is(evt.target, matching)) {
        handler.call(this, evt);
    }

    this.removeAttribute(randomID);
}
354064
def _updateTargetFromNode(self):
        
        self.viewBox.setAspectLocked(lock=self.configValue, ratio=self.aspectRatioCti.configValue)
781675
@Override
    public void set(IQueryAtomContainer source, IAtomContainer target) {
        this.source = source;
        this.target = target;
    }
999340
function (name, state) {
        var self = this;

        // Never bind focus/blur since the FocusManager fakes those
        if (name == "focus" || name == "blur") {
          return;
        }

        if (state) {
          if (self.initialized) {
            bindEventDelegate(self, name);
          } else {
            if (!self._pendingNativeEvents) {
              self._pendingNativeEvents = [name];
            } else {
              self._pendingNativeEvents.push(name);
            }
          }
        } else if (self.initialized) {
          self.dom.unbind(getEventTarget(self, name), name, self.delegates[name]);
          delete self.delegates[name];
        }
      }