TypeScript api.Renderer类代码示例

 _createPooledView(protoView: viewModule.AppProtoView): viewModule.AppView {
   var view = this._viewPool.getView(protoView);
   if (isBlank(view)) {
     view = this._utils.createView(protoView, this._renderer.createView(protoView.render), this,
                                   this._renderer);
     this._renderer.setEventDispatcher(view.render, view);
     this._createViewRecurse(view);
   }
   return view;
 }

 private _createViewHelper(args: List<any>, method) {
   var hostProtoView = this._serializer.deserialize(args[0], RenderProtoViewRef);
   var fragmentCount = args[1];
   var startIndex, renderViewWithFragments;
   if (method == "createView") {
     startIndex = args[2];
     renderViewWithFragments = this._renderer.createView(hostProtoView, fragmentCount);
   } else {
     var selector = args[2];
     startIndex = args[3];
     renderViewWithFragments =
         this._renderer.createRootHostView(hostProtoView, fragmentCount, selector);
   }
   this._renderViewWithFragmentsStore.store(renderViewWithFragments, startIndex);
 }

  createRootHostView(hostProtoViewRef: ProtoViewRef, overrideSelector: string,
                     injector: Injector): ViewRef {
    var hostProtoView = internalProtoView(hostProtoViewRef);
    var hostElementSelector = overrideSelector;
    if (isBlank(hostElementSelector)) {
      hostElementSelector = hostProtoView.elementBinders[0].componentDirective.metadata.selector;
    }
    var renderView = this._renderer.createRootHostView(hostProtoView.render, hostElementSelector);
    var hostView = this._utils.createView(hostProtoView, renderView, this, this._renderer);
    this._renderer.setEventDispatcher(hostView.render, hostView);
    this._createViewRecurse(hostView);

    this._utils.hydrateRootHostView(hostView, injector);
    this._viewHydrateRecurse(hostView);
    return new ViewRef(hostView);
  }

  _viewDehydrateRecurse(view: viewModule.AppView, forceDestroyComponents) {
    this._utils.dehydrateView(view);
    this._renderer.dehydrateView(view.render);
    var binders = view.proto.elementBinders;
    for (var i = 0; i < binders.length; i++) {
      var componentView = view.componentChildViews[i];
      if (isPresent(componentView)) {
        if (binders[i].hasDynamicComponent() || forceDestroyComponents) {
          this._destroyComponentView(view, i, componentView);
        } else {
          this._viewDehydrateRecurse(componentView, false);
        }
      }
      var vc = view.viewContainers[i];
      if (isPresent(vc)) {
        for (var j = vc.views.length - 1; j >= 0; j--) {
          this._destroyViewInContainer(view, i, j);
        }
        for (var j = vc.freeViews.length - 1; j >= 0; j--) {
          this._destroyFreeEmbeddedView(view, i, j);
        }
      }
    }

    // freeHostViews
    for (var i = view.freeHostViews.length - 1; i >= 0; i--) {
      var hostView = view.freeHostViews[i];
      this._destroyFreeHostView(view, hostView);
    }
  }

 insert(view, atIndex=-1): viewModule.AppView {
   if (atIndex == -1) atIndex = this._views.length;
   this._insertInjectors(view, atIndex);
   this.parentView.changeDetector.addChild(view.changeDetector);
   this.renderer.insertViewIntoContainer(this.render, atIndex, view.render);
   return view;
 }

 /**
  * The method can be used together with insert to implement a view move, i.e.
  * moving the dom nodes while the directives in the view stay intact.
  */
 detach(atIndex=-1): viewModule.AppView {
   if (atIndex == -1) atIndex = this._views.length - 1;
   var detachedView = this._detachInjectors(atIndex);
   detachedView.changeDetector.remove();
   this.renderer.detachViewFromContainer(this.render, atIndex);
   return detachedView;
 }

 _destroyPooledView(view: viewModule.AppView) {
   var wasReturned = this._viewPool.returnView(view);
   if (!wasReturned) {
     this._renderer.destroyView(view.render);
     this._viewListener.viewDestroyed(view);
   }
 }

 _destroyComponentView(hostView, boundElementIndex, componentView) {
   this._viewDehydrateRecurse(componentView, false);
   this._renderer.detachComponentView(hostView.elementRefs[boundElementIndex],
                                      componentView.render);
   this._utils.detachComponentView(hostView, boundElementIndex);
   this._destroyPooledView(componentView);
 }

 viewCreated(view: AppView) {
   var viewId = _nextId++;
   _allViewsById.set(viewId, view);
   _allIdsByView.set(view, viewId);
   for (var i = 0; i < view.elementRefs.length; i++) {
     _setElementId(this._renderer.getNativeElementSync(view.elementRefs[i]), [viewId, i]);
   }
 }

 detachViewInContainer(viewContainerLocation: ElementRef, atIndex: number): ViewRef {
   var parentView = internalView(viewContainerLocation.parentView);
   var boundElementIndex = viewContainerLocation.boundElementIndex;
   var viewContainer = parentView.viewContainers[boundElementIndex];
   var view = viewContainer.views[atIndex];
   this._utils.detachViewInContainer(parentView, boundElementIndex, atIndex);
   this._renderer.detachViewInContainer(viewContainerLocation, atIndex, view.render);
   return view.ref;
 }