Recursively render all children, placing their
output in our template.
967702
public function recursiveRender()
    {
        foreach ($this->elements as $view) {
            if (!$view instanceof self) {
                continue;
            }

            $this->template->appendHTML($view->region, $view->getHTML());

            if ($view->_js_actions) {
                $this->_js_actions = array_merge_recursive($this->_js_actions, $view->_js_actions);
            }
        }

        if (isset($this->content) && $this->content !== false) {
            $this->template->append('Content', $this->content);
        }
    }
987681
def render(self, **kwargs):
        """"""
        for name, child in self._children.items():
            child.render(**kwargs)
        return self._template.render(this=self, kwargs=kwargs)
634670
function renderAll(files, data, outputDir) {

  for (var i = 0; i < files.length; i++) {
    render(files[i], data, outputDir)
  }

}
745940
def render(self, **kwargs):
        """"""
        return self._template.render(this=self, kwargs=kwargs)
794412
def children(self, recursive=False):
        
        for i in xrange(self.childCount()):
            child = self.child(i)
            yield child
            
            if recursive:
                for subchild in child.children(recursive=True):
                    yield subchild
1001629
def render options = {}
      validate!
      options = fill_options(options)

      open = render_open_tag(options)
      inner = render_children(options)
      close = render_close_tag(options)

      if options[:pretty]
        indent = ' ' * (options[:indent] * options[:depth])
        out = indent.dup
        out << open << "\n"
        out << inner if inner
        out << indent << close << "\n" if close && !close.empty?
        out
      else
        out = open
        out << inner if inner
        out << close if close
        out
      end
    end
227938
public function render()
    {
        $iter = $this->getIterator();
        foreach ($iter as $this->current_id => $this->current_row) {
            if ($this->current_row instanceof Model || $this->current_row instanceof \atk4\data\Model) {
                /** @type Model $this->current_row */
                $this->current_row = $this->current_row->get();
            } elseif (!is_array($this->current_row) && !($this->current_row instanceof ArrayAccess)) {
                // Looks like we won't be able to access current_row as array, so we will
                // copy it's value inside $this->current instead and produce an empty array
                // to be filled out by a custom iterators
                $this->current = $this->current_row;
                $this->current_row = get_object_vars($this->current);
            }

            $this->formatRow();
            $this->output($this->rowRender($this->template));
        }
    }
1002815
protected function RenderImpl()
    {
        $i = 0;
        $children = pq('[zippy=' . $this->id . ']  source');
        foreach ($children as $child) {
            if (strlen($this->sources[$i]) > 0) {
                pq($child)->attr("src", $this->sources[$i]);
                $i++;
            }
        }

        if (strlen($this->src) > 0)
            $this->setAttribute("src", $this->src);
    }
47458
def render(self, node):
        
        lines = []

        children = self.traverse.get_children(node)
        lines.append(self.draw.node_label(self.traverse.get_text(node)))

        for n, child in enumerate(children):
            child_tree = self.render(child)

            if n == len(children) - 1:
                # last child does not get the line drawn
                lines.append(self.draw.last_child_head(child_tree.pop(0)))
                lines.extend(self.draw.last_child_tail(l)
                             for l in child_tree)
            else:
                lines.append(self.draw.child_head(child_tree.pop(0)))
                lines.extend(self.draw.child_tail(l)
                             for l in child_tree)

        return lines
290154
def iter_all_children(self):
        '''
        '''
        
        if self.inline_child:
            yield self.inline_child
        for x in self.children:
            yield x
324597
def _render(self):
        """"""
        return list(self._parent)[self._start:self._stop:self._step]
1357020
public function renderOut()
    {
        foreach (Error::all() as $file => $error) {
            foreach ($error as $line) {
                $this->addMessage('Template error: ' . $line . '(' . $file . ')', 'error');
            }
        }
        return $this->render->render();
    }
1164934
public function render() {

		$output = $this->render_template();
		if ( ! empty( $this->child ) ) {
			$output .= '<div ' . $this->build_attributes() . '>';
			$output .= $this->render_children();
			$output .= '</div>';
		}

		return $output;
	}
1229112
public function renderDataRow()
    {
        $this->formatRow();

        $this->template->appendHTML(
            $this->container_tag,
            $this->rowRender($this->row_t)
        );
    }
488408
protected function displayChildren()
    {
        foreach ($this->children as &$child) {
            ob_start();
            $child->display();
            $content = ob_get_clean();
            if ($content != '') {
                echo '<li>', $content, '</li>';
            }
        }
    }
806540
def render(self, element):
        
        # Store the root node to provide some context to render functions
        if not self.root_node:
            self.root_node = element
        render_func = getattr(
            self, self._cls_to_func_name(element.__class__), None)
        if not render_func:
            render_func = self.render_children
        return render_func(element)
1221335
def render(self, **kwargs):
        """"""
        for item in self._parent._children.values():
            if not isinstance(item, Layer) or not item.control:
                continue
            key = item.layer_name
            if not item.overlay:
                self.base_layers[key] = item.get_name()
                if len(self.base_layers) > 1:
                    self.layers_untoggle[key] = item.get_name()
            else:
                self.overlays[key] = item.get_name()
                if not item.show:
                    self.layers_untoggle[key] = item.get_name()
        super(LayerControl, self).render()