IObjectActionDelegate
9490
public void setActivePart(IAction action, IWorkbenchPart targetPart)
	{
		setAction(action);
		setPart(targetPart);
		update();
	}
251594
public void processAction() throws IOException {
		if (isDisposed()) {
			LOG.error("Skipping action phase. Attempt to reuse disposed ContainerHelper instance");
			return;
		}

		try {
			// Check user context has been prepared
			if (getNewConversation() == null) {
				throw new IllegalStateException(
						"User context has not been prepared before the action phase");
			}

			prepareAction();

			UIContext uic = getUIContext();
			if (uic == null) {
				throw new IllegalStateException("No user context set for the action phase.");
			}

			UIContextHolder.pushContext(uic);

			// Make sure maps are cleared up
			uic.clearScratchMap();
			uic.clearRequestScratchMap();

			prepareRequest();

			Request req = getRequest();
			getInterceptor().attachResponse(getResponse());
			getInterceptor().serviceRequest(req);

			if (req.isLogout()) {
				handleLogout();
				dispose();
			}
		} catch (ActionEscape esc) {
			LOG.debug("ActionEscape performed.");
			// Action escapes must be handled in the action phase and then
			// do nothing if they reach the render phase (which they will in
			// the servlet implementation)
			handleEscape(esc);
			dispose();
		} catch (Escape esc) {
			LOG.debug("Escape performed during action phase.");
			// We can't handle the escape until the render phase.
		} catch (Throwable t) {
			// We try not to let any exception propagate to container.
			String message = "Caught exception during action phase.";
			LOG.error(message, t);

			// We can't handle the error until the render phase.
			propogateError(t);
		} finally {
			UIContextHolder.reset();
		}
	}
1181241
private void init()
    {
        TreeNode delegateRoot = null;
        if (delegate != null)
        {
            delegateRoot = (TreeNode) delegate.getRoot();
        }
        thisToDelegate.clear();
        delegateToThis.clear();
        if (delegateRoot == null)
        {
            root = null;
            return;
        }
        root = createNode(delegateRoot);
    }
818851
def ilabel(object_name, method, content_or_options = nil, options = nil, &block)
      options ||= {}

      content_is_options = content_or_options.is_a?(Hash)
      if content_is_options || block_given?
        options.merge!(content_or_options) if content_is_options
        text = nil
      else
        text = content_or_options
      end

      ActionView::Helpers::InstanceTag.new(object_name, method, self, options.delete(:object)).to_ilabel_tag(text, options, &block)
    end
1071304
public void delegatedAccount_email_updateUsage_POST(String email) throws IOException {
		String qPath = "/email/domain/delegatedAccount/{email}/updateUsage";
		StringBuilder sb = path(qPath, email);
		exec(qPath, "POST", sb.toString(), null);
	}
245364
protected void handleObjectPressed (final SceneObject scobj, int mx, int my)
    {
        String action = scobj.info.action;
        final ObjectActionHandler handler = ObjectActionHandler.lookup(action);

        // if there's no handler, just fire the action immediately
        if (handler == null) {
            fireObjectAction(null, scobj, new SceneObjectActionEvent(
                                 this, 0, action, 0, scobj));
            return;
        }

        // if the action's not allowed, pretend like we handled it
        if (!handler.actionAllowed(action)) {
            return;
        }

        // if there's no menu for this object, fire the action immediately
        RadialMenu menu = handler.handlePressed(scobj);
        if (menu == null) {
            fireObjectAction(handler, scobj, new SceneObjectActionEvent(
                                 this, 0, action, 0, scobj));
            return;
        }

        // make the menu surround the clicked object, but with consistent size
        Rectangle mbounds = getRadialMenuBounds(scobj);

        _activeMenu = menu;
        _activeMenu.addActionListener(new ActionListener() {
            public void actionPerformed (ActionEvent e) {
                if (e instanceof CommandEvent) {
                    fireObjectAction(handler, scobj, e);
                } else {
                    SceneObjectActionEvent event = new SceneObjectActionEvent(
                        e.getSource(), e.getID(), e.getActionCommand(),
                        e.getModifiers(), scobj);
                    fireObjectAction(handler, scobj, event);
                }
            }
        });
        _activeMenu.activate(this, mbounds, scobj);
    }
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);
        }
1112825
public void onAttach() {
		for (MvpPresenter<? super Delegated> presenter : mPresenters) {
			if (mIsAttached && presenter.getAttachedViews().contains(mDelegated)) {
				continue;
			}

			presenter.attachView(mDelegated);
		}

		for (MvpDelegate<?> childDelegate : mChildDelegates) {
			childDelegate.onAttach();
		}

		mIsAttached = true;
	}
18253
private void delegate(RequestDelegationService service, HttpServletRequest request, HttpServletResponse response,
        FilterChain filterChain) {
        try {
            service.delegate(request, response, filterChain);
        } catch (Exception e) {
            throw new RequestDelegationException(
                String.format("The request processing delegation failed: %s", e.getCause()), e);
        }
    }
301975
function addDelegatedListener(el, type, listener) {
  incrementListenerCount(listener);
  return el.addEventListener(type, getDelegateFunction_(listener));
}
1283772
private synchronized void putDelegate(final List<Tasklet> tasklets, final VortexFutureDelegate delegate) {
    for (final Tasklet tasklet : tasklets) {
      taskletFutureMap.put(tasklet.getId(), delegate);
    }
  }
59026
public synchronized void setDelegateMap(PropertyMap delegateMap)
    {
        if (!isCompatibleClass(delegateMap.getMapClass()))
            throw new IllegalArgumentException("The delegate map type (" + delegateMap.getMapClass() + " is an incompatible type with " + _mapClass);

        _delegateMap = delegateMap;
    }
994377
private void writeObject(java.io.ObjectOutputStream out) throws IOException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            Tr.entry(tc, "writeObject : " + ivPuId + ", " + ivJ2eeName);

        out.writeObject(ivPuId);
        out.writeObject(ivJ2eeName); // d510184

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            Tr.exit(tc, "writeObject");
    }
1317799
@Override
	public void associateTargetWith( String targetId, AbstractApplication app, String instancePathOrComponentName )
	throws IOException, UnauthorizedActionException {

		boolean valid = false;
		if( instancePathOrComponentName == null ) {
			valid = true;

		} else if( instancePathOrComponentName.startsWith( "@" )) {
			Component comp = ComponentHelpers.findComponent( app, instancePathOrComponentName.substring( 1 ));
			valid = comp != null;

		} else {
			Instance instance = InstanceHelpers.findInstanceByPath( app, instancePathOrComponentName );
			valid = instance != null;
			if( instance != null ) {
				if( instance.getStatus() != InstanceStatus.NOT_DEPLOYED )
					throw new UnauthorizedActionException( "Operation not allowed: " + app + " :: " + instancePathOrComponentName + " should be not deployed." );

				if( ! InstanceHelpers.isTarget( instance ))
					throw new IllegalArgumentException( "Only scoped instances can be associated with targets. Path in error: " + instancePathOrComponentName );
			}
		}

		if( valid )
			saveAssociation( app, targetId, instancePathOrComponentName, true );
	}
220469
public void registerUserObject(final Object iObject, final ORecordInternal<?> iRecord) {
		if (!(iRecord instanceof ODocument))
			return;

		final ODocument doc = (ODocument) iRecord;

		if (retainObjects) {
			if (iObject != null) {
				objects2Records.put(iObject, doc);
				records2Objects.put(doc, (T) iObject);

				OObjectSerializerHelper.setObjectID(iRecord.getIdentity(), iObject);
				OObjectSerializerHelper.setObjectVersion(iRecord.getVersion(), iObject);
			}

			final ORID rid = iRecord.getIdentity();
			if (rid.isValid())
				rid2Records.put(rid, doc);
		}
	}
11329
private function initDelegates()
    {
        // start event dispatching
        $this->eventDispatcher = new EventDispatcher;
        
        // create operator
        $this->operator = $this->getCollection()->operator();

        // attach behaviors
        $this->attachBehaviors($this->behaviors());
        if ($this->hasOption('behaviors')) {
            $this->attachBehaviors($this->getOption('behaviors'));
        }
    }
179565
private ArrayListImpl<ChildLink<T>> modifiableDelegate() {
    if (delegate.getCount() != 0) {
      delegate = new ArrayListImpl<>(delegate);
    }
    return delegate;
  }