Will render the provided data result with the provided {@link Renderer}.
This method will also check if recycling is enabled (You can turn on recycling by setting {@link this#setRecycleManager(RecycleManager)}.
507151
private void render(List<T> data) {
        List<Widget> widgets = new ArrayList<>();
        for (T model : data) {
            Widget widget = renderer.render(model);
            widget.getElement().setId("item-" + itemCount);
            add(widget);
            widgets.add(widget);
            itemCount++;
        }

        // Check if recycling is enabled
        if (isEnableRecycling()) {
            recycleManager.recycleWidgets(widgets);
        }

        // Will force the scroll panel to have a scroll if it isn't visible
        if (!hasScrollBar()) {
            int height = $(widgets.get(0).getElement()).outerHeight();
            getElement().getStyle().setHeight(height, Style.Unit.PX);
        }
    }
34813
@Override
	public void render() {
		uri = ActionContext.getContextPath() + uri;
		try {
			Response.getServletResponse().sendRedirect(uri);
		} catch (IOException e) {
			throw new RenderException("Redirect to [" + uri + "] error!", e);
		}
	}
1025311
@Override
	public void doRender(final WComponent component, final WebXmlRenderContext renderContext) {
		WRepeater repeater = (WRepeater) component;
		XmlStringBuilder xml = renderContext.getWriter();

		xml.appendTagOpen("ui:panel");
		xml.appendAttribute("id", component.getId());
		xml.appendOptionalAttribute("class", component.getHtmlClass());
		xml.appendOptionalAttribute("track", component.isTracking(), "true");
		xml.appendClose();

		xml.appendTag("ui:content");
		paintRows(repeater, renderContext);
		xml.appendEndTag("ui:content");

		xml.appendEndTag("ui:panel");
	}
787334
@SuppressWarnings("unused")
    private static void releaseRenderer() 
    {
        if (log.isLoggable(Level.FINEST))
        {
            log.finest("releaseRenderer rendererMap -> " + delegateRendererMap.toString());
        }
        
        
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        
        if (log.isLoggable(Level.FINEST))
        {
            log.finest("releaseRenderer classLoader -> " + classLoader.toString() );
            log.finest("releaseRenderer renderer -> " + delegateRendererMap.get(classLoader));
        }
        
        
        delegateRendererMap.remove(classLoader);
        
        if (log.isLoggable(Level.FINEST))
        {
            log.finest("releaseRenderer renderMap -> " + delegateRendererMap.toString());
        }
        
    }
445701
private void renderRenderable(IAnimatedRenderable renderable)
	{
		this.renderable = renderable;
		set(renderable.getWorld(), renderable.getPos());
		posOffset = new Vec3d(pos.getX(), pos.getY(), pos.getZ());

		renderable.renderAnimated(block, this);
	}
806013
private void adaptItemColor() {
        if (adapter != null) {
            RecyclerView.Adapter<?> wrappedAdapter = adapter.getWrappedAdapter();

            if (wrappedAdapter instanceof ArrayRecyclerViewAdapter) {
                ((ArrayRecyclerViewAdapter) wrappedAdapter).setItemColor(itemColor);
            }
        }
    }
522865
@Override
    public ChunkedActionRenderResult renderBody(ODataRequestContext requestContext, QueryResult result,
                                                ChunkedActionRenderResult previousResult) throws ODataException {
        LOG.debug("Start rendering property for request body: {}", requestContext);
        ODataResponse.Builder responseBuilder = new ODataResponse.Builder().setStatus(OK);
        render(requestContext, result, responseBuilder);
        try {
            previousResult.getOutputStream().write(responseBuilder.build().getBody());
            return previousResult;
        } catch (java.io.IOException e) {
            throw new ODataRenderException(format("Unable to render result: {0} for request: {1}",
                    result, requestContext.getRequest()), e);
        }
    }
228901
def render(self, data, accepted_media_type=None, renderer_context=None):
        
        renderer_context = renderer_context or {}
        callback = self.get_callback(renderer_context)
        json = super(JSONPRenderer, self).render(data, accepted_media_type,
                                                 renderer_context)
        return callback.encode(self.charset) + b'(' + json + b');'
922629
public void setRenderInline(final boolean renderInline) {
		if (renderInline != getRenderInline()) {
			ImageEditModel model = getOrCreateComponentModel();
			model.renderInline = renderInline;
		}
	}
379666
@Override
	public void render() {
		final HttpServletResponse response = Response.getServletResponse();
		response.setContentType(this.contentType);
		ServletOutputStream out = null;
		try {
			out = Response.getOutputStream();
			this.template.render(Request.getParamMap(), out);
		} catch (IOException e) {
			throw new IORuntimeException(e);
		} finally {
			IoUtil.close(out);
		}
	}
927237
@Override
	public void render(GuiRenderer renderer)
	{
		update();
		if (StringUtils.isEmpty(cache))
			return;

		int x = screenPosition.x();
		int y = screenPosition.y();
		int z = zIndex.getAsInt();
		ClipArea area = null;
		if (parent instanceof UIComponent)
			z += parent.getZIndex();
		if (parent instanceof IClipable)
			area = ((IClipable) parent).getClipArea();
		render(renderer, x, y, z, area);
	}
155835
public static void result(final RequestContext context) {
        final HttpServletResponse response = context.getResponse();
        if (response.isCommitted()) { // Response sends redirect or error
            return;
        }

        AbstractResponseRenderer renderer = context.getRenderer();
        if (null == renderer) {
            renderer = new Http404Renderer();
        }
        renderer.render(context);
    }
1305192
@Override
  public FutureResultImpl<T> setResult(T result) {
    this.result = result;
    succeeded = true;
    checkCallHandler();
    return this;
  }
1076643
function RenderManager(generator, config, logger) {
        events.EventEmitter.call(this);

        this._generator = generator;
        this._config = config;
        this._logger = logger;

        this._svgRenderers = {};
        this._pixmapRenderers = {};

        this._componentsByDocument = {};
        this._pending = {};
        this._working = {};

        this._renderedAssetCount = 0;
    }
1162931
@Provides protected RendererAdapter<TvShowViewModel> provideTvShowRendererAdapter(
      LayoutInflater layoutInflater,
      TvShowCollectionRendererBuilder tvShowCollectionRendererBuilder,
      TvShowCollectionViewModel tvShowCollectionViewModel) {
    return new RendererAdapter<TvShowViewModel>(layoutInflater, tvShowCollectionRendererBuilder,
        tvShowCollectionViewModel);
  }
1179927
@Override
    public void render() {
        GdxUtilities.clearScreen();
        if (currentView != null) {
            currentView.render(Gdx.graphics.getDeltaTime());
        }
    }
292428
def makeRenderer(rdrid, dp, refresh=False):
    """"""
    try:
        return available_renderers[rdrid][0](dp, refresh=refresh)
    except:
        print("""Error creating renderer %s for %s:""" % (rdrid, dp.fullpath))
        traceback.print_exc()
        return DefaultRenderer(dp)