@Override public void use(Collection<Object> values) { for (Object value : values) { use(value); } }
/** * @param type the type of skin extension * @param resource the resource to register * @param parameters the parameters */ public void use(String type, String resource, Map<String, Object> parameters) { this.asyncContext.use(USER_TYPE, new SkinExtensionInfo(type, resource, parameters)); } }
private void use(Object value) { SkinExtensionInfo info = (SkinExtensionInfo) value; // Find the right skin extension SkinExtension skinExtension; try { skinExtension = this.componentManager.getInstance(SkinExtension.class, info.getType()); } catch (ComponentLookupException e) { this.logger.error("Failed to load the skin extension with type [{}]", info.getType(), e); return; } // Inject the skin extension if (info.getParameters() != null) { skinExtension.use(info.getResource(), info.getParameters()); } else { skinExtension.use(info.getResource()); } }
@Override public void addHTMLHead(StringBuilder meta, Collection<Object> values) { // TODO: A bit hacky right now, the skinx module should be refactored to be fully based on components XWikiContext xcontext = this.xcontextProvider.get(); List<XWikiPluginInterface> plugins = xcontext.getWiki().getPluginManager().getPlugins("endParsing"); for (Object value : values) { SkinExtensionInfo info = (SkinExtensionInfo) value; AbstractSkinExtensionPlugin skinPlugin = getPlugin(info.getType(), plugins); if (skinPlugin != null) { meta.append(skinPlugin.getLink(info.getResource(), xcontext)); } else { this.logger.warn("Cannot find skin extension plugin for resource type [{}]", info.getType()); } } }
/** * Mark a resource as used in the current result. A resource is registered only once per request, further calls will * not result in additional links, even if it is pulled with different parameters. * * @param resource The name of the resource to pull. * @param context The current request context. * @see #use(String, Map, XWikiContext) */ public void use(String resource, XWikiContext context) { useResource(resource, context); // In case a previous call added some parameters, remove them, since the last call for a resource always // discards previous ones. getParametersMap(context).remove(resource); // Register the use of the resource in case the current execution is an asynchronous renderer getSkinExtensionAsync().use(getName(), resource, null); }
/** * Mark a skin extension document as used in the current result, together with some parameters. How the parameters * are used, depends on the type of resource being pulled. For example, JS and CSS extensions use the parameters in * the resulting URL, while Link extensions use the parameters as attributes of the link tag. A resource is * registered only once per request, further calls will not result in additional links, even if it is pulled with * different parameters. If more than one calls per request are made, the parameters used are the ones from the last * call (or none, if the last call did not specify any parameters). * * @param resource The name of the resource to pull. * @param parameters The parameters for this resource. * @param context The current request context. * @see #use(String, XWikiContext) */ public void use(String resource, Map<String, Object> parameters, XWikiContext context) { useResource(resource, context); // Associate parameters to the resource getParametersMap(context).put(resource, parameters); getSkinExtensionAsync().use(getName(), resource, parameters); }