register item render by virtual view* @param type
422677
public <V extends View> void registerVirtualView(String type) {
        mDefaultCellBinderResolver.register(type, new BaseCellBinder<>(type, mMVHelper));
        registerCard(type, VVCard.class);
    }
753922
protected void registerAllTypeVariables(Type classType) {
        Queue<Type> typesToRegister = new LinkedList<Type>();
        Set<Type> registeredTypes = new HashSet<Type>();
        typesToRegister.add(classType);

        while (!typesToRegister.isEmpty()) {
            Type typeToRegister = typesToRegister.poll();
            if (typeToRegister == null || registeredTypes.contains(typeToRegister)) {
                continue;
            }

            registerTypeVariablesOn(typeToRegister);
            registeredTypes.add(typeToRegister);

            Class<?> rawType = extractRawTypeOf(typeToRegister);
            typesToRegister.add(rawType.getGenericSuperclass());
            typesToRegister.addAll(Arrays.asList(rawType.getGenericInterfaces()));
        }
    }
1118345
def register_view(self, view):
        
        super(StateDataFlowsListController, self).register_view(view)

        def cell_text(column, cell_renderer, model, iter, container_model):
            df_id = model.get_value(iter, self.ID_STORAGE_ID)
            in_external = 'external' if model.get_value(iter, self.IS_EXTERNAL_STORAGE_ID) else 'internal'

            if column.get_title() == 'Source State':
                cell_renderer.set_property("model", self.tree_dict_combos[in_external][df_id]['from_state'])
                cell_renderer.set_property("text-column", 0)
                cell_renderer.set_property("has-entry", False)
            elif column.get_title() == 'Source Port':
                cell_renderer.set_property("model", self.tree_dict_combos[in_external][df_id]['from_key'])
                cell_renderer.set_property("text-column", 0)
                cell_renderer.set_property("has-entry", False)
            elif column.get_title() == 'Target State':
                cell_renderer.set_property("model", self.tree_dict_combos[in_external][df_id]['to_state'])
                cell_renderer.set_property("text-column", 0)
                cell_renderer.set_property("has-entry", False)
            elif column.get_title() == 'Target Port':
                cell_renderer.set_property("model", self.tree_dict_combos[in_external][df_id]['to_key'])
                cell_renderer.set_property("text-column", 0)
                cell_renderer.set_property("has-entry", False)
            else:
                logger.warning("Column has no cell_data_func %s %s" % (column.get_name(), column.get_title()))

        view['from_state_col'].set_cell_data_func(view['from_state_combo'], cell_text, self.model)
        view['to_state_col'].set_cell_data_func(view['to_state_combo'], cell_text, self.model)
        view['from_key_col'].set_cell_data_func(view['from_key_combo'], cell_text, self.model)
        view['to_key_col'].set_cell_data_func(view['to_key_combo'], cell_text, self.model)

        if self.model.state.get_next_upper_library_root_state():
            view['from_state_combo'].set_property("editable", False)
            view['from_key_combo'].set_property("editable", False)
            view['to_state_combo'].set_property("editable", False)
            view['to_key_combo'].set_property("editable", False)
        else:
            self.connect_signal(view['from_state_combo'], "edited", self.on_combo_changed_from_state)
            self.connect_signal(view['from_key_combo'], "edited", self.on_combo_changed_from_key)
            self.connect_signal(view['to_state_combo'], "edited", self.on_combo_changed_to_state)
            self.connect_signal(view['to_key_combo'], "edited", self.on_combo_changed_to_key)

        self.tree_view.connect("grab-focus", self.on_focus)
        self.update(initiator='"register view"')
1245062
function registerView(view) {
  var name = view.getDebugName();
  var wrapped = new RegistryWrapper(view, 'views');
  flatRegistry.views[name] = wrapped;
  if (!view.parentView && !view.isComponentView) {
    nestedRegistry.views[name] = wrapped;
  }
  if (typeof view.destroy === 'function') {
    wrapped.destroy = _.bind(view.destroy, view);
    view.destroy = _.bind(function() {
      var name = this.obj.getDebugName();
      delete nestedRegistry.views[name];
      delete flatRegistry.views[name];
      updateNestedModels();
      triggerChange();
      this.destroy();
    }, wrapped);
  }
  updateNestedModels();
  triggerChange();
}
755466
@Override
    public <T> RegistrationAnnotatedBindingBuilder<T> register(Class<T> type) {
        return new RegistrationBindingBuilderImpl<>(binder, type);
    }
1302325
function renderStateless (_vdom, props, isSvg) {
  var collector = new Collector()
  var vdom = _vdom.type(props)
  collector.append(rawRender(vdom, isSvg))
  return collector.get()
}
327781
public static <T> void registerReader(Class<T> type, JsonReaderI<T> mapper) {
		defaultReader.registerReader(type, mapper);
	}
888775
public void addVariable(String name, TypeMirror type)
    {
        localVariables.add(new LocalVariable(executableElement, type, name));
    }
670055
public SerializerRegistry register(Class<?> type) {
    if (type == null)
      throw new NullPointerException("type cannot be null");
    return register(type, calculateTypeId(type));
  }
1357545
private void renderItemValue(MenuItem item) {

        // only proceed if there's a label to be updated..
        Label lblForVal = itemIdToLabel.get(item.getId());
        if (lblForVal == null) return;

        //
        // First we use the visitor again to call the right method in the visitor based on it's type.
        // The visitors setResult stores a string value that it to be used for rendering.
        //
        Optional<String> value = MenuItemHelper.visitWithResult(item, new AbstractMenuItemVisitor<>() {

            /**
             * Render an analog item into the label, notice it has to apply the offset and divisor.
             * @param item the item to display
             */
            @Override
            public void visit(AnalogMenuItem item) {
                MenuState<Integer> state = menuTree.getMenuState(item);
                if (state != null) {
                    double val = (double) (state.getValue() + item.getOffset());
                    val = val / ((double) item.getDivisor());
                    setResult(String.format("%.2f%s", val, item.getUnitName()));
                }
            }

            /**
             * Render a boolean item, taking into account the different types of boolean naming.
             * @param item the item to render
             */
            @Override
            public void visit(BooleanMenuItem item) {
                MenuState<Boolean> state = menuTree.getMenuState(item);
                if (state != null) {
                    switch (item.getNaming()) {
                        case ON_OFF:
                            setResult(state.getValue() ? "ON" : "OFF");
                            break;
                        case YES_NO:
                            setResult(state.getValue() ? "YES" : "NO");
                            break;
                        case TRUE_FALSE:
                        default:
                            setResult(state.getValue() ? "TRUE" : "FALSE");
                            break;
                    }
                }
            }

            /**
             * Render an enumeration by displaying it's printable name for the chosen index
             * @param item the item to render
             */
            @Override
            public void visit(EnumMenuItem item) {
                MenuState<Integer> state = menuTree.getMenuState(item);
                if (state != null) {
                    setResult(item.getEnumEntries().get(state.getValue()));
                }
            }

            /**
             * Render a remote item by displaying the connection status contained in the object
             * @param item the remote item to render
             */
            @Override
            public void visit(RemoteMenuItem item) {
                MenuState<String> state = menuTree.getMenuState(item);
                if(state != null) {
                    setResult(state.getValue());
                }
            }

            /**
             * Render a floating point item to the number of decimal places configured.
             * @param item the floating point item to render.
             */
            @Override
            public void visit(FloatMenuItem item) {
                MenuState<Float> state = menuTree.getMenuState(item);
                if(state != null) {
                    NumberFormat fmt = NumberFormat.getInstance();
                    fmt.setGroupingUsed(false);
                    fmt.setMinimumFractionDigits(item.getNumDecimalPlaces());
                    fmt.setMaximumFractionDigits(item.getNumDecimalPlaces());
                    setResult(fmt.format(state.getValue()));
                }
            }

            /**
             * Render a text value simply by using its current value.
             * @param item the item to render.
             */
            @Override
            public void visit(TextMenuItem item) {
                MenuState<String> state = menuTree.getMenuState(item);
                if (state != null) {
                    setResult(state.getValue());
                }
            }

            /**
             * For anything else, do nothing.
             * @param item an item type we are not rendering.
             */
            @Override
            public void anyItem(MenuItem item) {
                setResult("");
            }
        });

        // And lastly set the text we just built into the label.
        lblForVal.setText(value.orElse("Not Present"));
        itemIdToChangeTicks.put(item.getId(), TICKS_HIGHLIGHT_ON_CHANGE);
    }
802688
function() {
      var canvasEl = fabric.document.createElement('canvas');

      if (!canvasEl.getContext && typeof G_vmlCanvasManager != 'undefined') {
        G_vmlCanvasManager.initElement(canvasEl);
      }

      this._render(canvasEl.getContext('2d'));
    }
461473
public final void register(Class type, Serializer serializer) {
        if (type == null) {
            throw new IllegalArgumentException("Class type information is required!");
        }
        if (serializer.getTypeId() <= 0) {
            throw new IllegalArgumentException(
                    "Type ID must be positive! Current: " + serializer.getTypeId() + ", Serializer: " + serializer);
        }
        safeRegister(type, createSerializerAdapter(serializer, this));
    }
1030582
public void register(Type<?> type) {
        jdbcTypeMapping.register(type.getSQLTypes()[0], type.getReturnedClass());
        javaTypeMapping.register(type);
    }
1010905
@Override
    public void renderItem(final Listitem item, final Document doc) {
        final Listcell cell = new Listcell();
        item.appendChild(cell);
        final Div sep = new Div();
        sep.setSclass("vista-documents-sep");
        cell.appendChild(sep);
        final Div div = new Div();
        div.setSclass(Constants.SCLASS_TEXT_REPORT_TITLE);
        cell.appendChild(div);
        final Hbox boxHeader = new Hbox();
        final Label header = new Label(doc.getTitle());
        header.setZclass(Constants.SCLASS_TEXT_REPORT_TITLE);
        boxHeader.appendChild(header);
        div.appendChild(boxHeader);
        Label body = new Label(doc.getBody());
        body.setMultiline(true);
        body.setPre(true);
        cell.appendChild(body);
    }
112635
public void registerAsType(Object locator, Class<?> type) {
		if (locator == null)
			throw new NullPointerException("Locator cannot be null");
		if (type == null)
			throw new NullPointerException("Type cannot be null");

		IComponentFactory factory = new DefaultComponentFactory(type);
		_registrations.add(new Registration(locator, factory));
	}
480929
def register_view(self, view):
        """"""
        super(TopToolBarUndockedWindowController, self).register_view(view)
        view['redock_button'].connect('clicked', self.on_redock_button_clicked)
1023077
protected function startRendering($type, ParsedTemplateInterface $parsedTemplate, RenderingContextInterface $renderingContext)
    {
        array_push($this->renderingStack, array('type' => $type, 'parsedTemplate' => $parsedTemplate, 'renderingContext' => $renderingContext));
    }