Renders the data items for the grid view.
492454
public function renderItems()
	{
		if ($this->json)
		{
			$renderedTableBody = $this->getRenderedTableBody();
			echo function_exists('json_encode')
				? json_encode($renderedTableBody)
				: CJSON::encode($renderedTableBody);
		}
		elseif ($this->dataProvider->getItemCount() > 0 || $this->showTableOnEmpty)
		{
			echo "<table class=\"{$this->itemsCssClass}\">\n";
			$this->renderTableHeader();
			$this->renderTableFooter(); // TFOOT must appear before TBODY according to the standard.
			$this->renderTableBody();
			echo "</table>";
			$this->renderTemplates();
		}
		else
		{
			$this->renderEmptyText();
		}
	}
1209849
public function renderView()
    {
        if ($this->class) {
            $this->template->append('class', implode(' ', $this->class));
        }

        if ($this->style) {
            $style = $this->style;
            array_walk(
                $style,
                function (&$item, $key) {
                    $item = $key.':'.$item;
                }
            );
            $this->template->append('style', implode(';', $style));
        }

        if ($this->ui) {
            if (is_string($this->ui)) {
                $this->template->set('_class', $this->ui);
            }
        } else {
            $this->template->tryDel('_ui');
        }

        if ($this->id) {
            $this->template->trySet('_id', $this->id);
        }

        if ($this->element) {
            $this->template->set('_element', $this->element);
        }

        if ($this->attr) {
            $tmp = [];
            foreach ($this->attr as $attr => $val) {
                $tmp[] = $attr.'="'.$this->app->encodeAttribute($val).'"';
            }
            $this->template->setHTML('attributes', implode(' ', $tmp));
        }
    }
1092983
public function renderRow()
    {
        $this->t_row->set($this->model);

        if ($this->use_html_tags) {
            // Prepare row-specific HTML tags.
            $html_tags = [];

            foreach ($this->hook('getHTMLTags', [$this->model]) as $ret) {
                if (is_array($ret)) {
                    $html_tags = array_merge($html_tags, $ret);
                }
            }

            foreach ($this->columns as $name => $columns) {
                if (!is_array($columns)) {
                    $columns = [$columns];
                }
                $field = $this->model->hasElement($name);
                foreach ($columns as $column) {
                    if (!method_exists($column, 'getHTMLTags')) {
                        continue;
                    }
                    $html_tags = array_merge($column->getHTMLTags($this->model, $field), $html_tags);
                }
            }

            // Render row and add to body
            $this->t_row->setHTML($html_tags);
            $this->t_row->set('_id', $this->model->id);
            $this->template->appendHTML('Body', $this->t_row->render());
            $this->t_row->del(array_keys($html_tags));
        } else {
            $this->template->appendHTML('Body', $this->t_row->render());
        }
    }
1191131
public function render()
    {
        $data = $this->grid->getViewData();
        $data['column'] = $this->column;
        $data['filter'] = $this;
        $data['label'] = $this->config->getLabel();
        return View::make(
            $this->getTemplate(),
            $data
        )->render();
    }
509816
public function renderDataCell($row)
    {
        $data = $this->grid->dataProvider->data[$row];
        $options = $this->htmlOptions;
        if ($this->cssClassExpression !== null) {
            $class = $this->evaluateExpression($this->cssClassExpression, array('row' => $row, 'data' => $data));
            if (isset($options['class']))
                $options['class'] .= ' ' . $class;
            else
                $options['class'] = $class;
        }
        echo CHtml::openTag('td', $options);
        echo CHtml::openTag('span', array('class' => $this->cssClass, 'data-rowid' => $this->getPrimaryKey($data)));
        $this->renderDataCellContent($row, $data);
        echo '</span>';
        echo '</td>';
    }
1003350
public function renderTotalsRow()
    {
        $this->current_row = $this->current_row_html = array();
        if ($this->totals !== false && is_array($this->totals) && $this->totals_t) {
            $this->current_row = $this->totals;

            $this->formatTotalsRow();

            $this->template->appendHTML(
                $this->container_tag,
                $this->rowRender($this->totals_t)
            );
        } else {
            $this->template->tryDel('totals');
        }
    }
432877
def render(self, view, context=None):
        """"""
        return self.runtime.render(self, view, context)
275844
@Override
	public void render() {
		String text = this.getErrorContent();
		if(isHtml){
			Response.setStatus(getErrorCode());
			new HtmlView(text).render();
		}else{
			super.render();
		}
	}
295900
protected function render()
	{
		if (empty($this->getContent())) {
			$parsed = YamlRender::parse($this->file->getContent());
			$this->setContent(is_array($parsed) ? $parsed : []);
		}
	}
1314952
protected function renderSubViews()
    {
        foreach ($this->subViews as $name => $views) {
            if (isset($this->viewData["subview_{$name}"]) === false) {
                $this->viewData["subview_{$name}"] = "";
            }

            foreach ($views as $view) {
                if (is_string($view)) {
                    $this->loader->setTemplate($view);
                    $this->viewData["subview_{$name}"] .= $this->loader->render(
                        $this->viewData,
                        Loader::TPL_RETURN,
                        Loader::TPL_CACHE_VARS
                    );
                    continue;
                }
                $this->viewData["subview_{$name}"] .= $view->render(
                    $this->viewData,
                    Loader::TPL_RETURN
                );
            }
        }
    }
688043
public function renderItems() {
		
		echo CHtml::openTag($this->itemsTagName, array('class' => $this->itemsCssClass)) . "\n";

		$data = $this->dataProvider->getData();

		if (!empty($data)) {
			echo CHtml::openTag('div', array('class' => 'row'));
			$owner = $this->getOwner();
			$render = $owner instanceof CController ? 'renderPartial' : 'render';
			foreach ($data as $i => $item) {
				$data = $this->viewData;
				$data['index'] = $i;
				$data['data'] = $item;
				$data['widget'] = $this;
				$owner->$render($this->itemView, $data);
			}

			echo '</div>';
		} else {
			$this->renderEmptyText();
		}

		echo CHtml::closeTag($this->itemsTagName);
	}
1348629
public function renderItems()
    {
        $thumbnails = array();
        $data = $this->dataProvider->getData();

        if (!empty($data)) {
            $owner = $this->getOwner();
            $render = $owner instanceof CController ? 'renderPartial' : 'render';
            foreach ($data as $i => $row) {
                $thumbnail = array();
                $d = $this->viewData;
                $d['index'] = $i;
                $d['data'] = $row;
                $d['widget'] = $this;
                $thumbnail['caption'] = $owner->$render($this->itemView, $d, true);
                if (isset($this->url)) {
                    $thumbnail['url'] = $this->evaluateExpression($this->url, array('data' => $row));
                }
                if (isset($this->span)) {
                    $thumbnail['span'] = $this->span;
                }
                $thumbnails[] = $thumbnail;
            }
            echo TbHtml::thumbnails($thumbnails, $this->htmlOptions);
        } else {
            $this->renderEmptyText();
        }
    }
1207527
protected function onRender()
    {
        if ($this->dataStore->countData() > 0) {
            //Update options
            $options = $this->options;
            if ($this->title) {
                $options["title"] = $this->title;
            }
            if ($this->colorScheme) {
                $options["colors"] = $this->colorScheme;
            }
            //Render
            $this->template(
                "Chart",
                array(
                    "chartType" => $this->type,
                    "options" => $options,
                    "data" => $this->prepareData(),
                    "cKeys" => array_keys($this->getColumnSettings()),
                    "loader"=>array(
                        "package"=>$this->package,
                        "stability"=>$this->stability,
                        "mapsApiKey"=>$this->mapsApiKey
                    )
                )
            );
        } else {
            $this->template("NoData");
        }
    }
755299
def render(self, rect, data):
        """"""
        # We can't use our get minimum size, because that enforces
        # the size limits.
        size = self.element.get_minimum_size(data)

        # Assume we're bottom left at our natural size.
        x = rect.x
        y = rect.y
        w = size.x
        h = size.y

        extra_width = rect.w - w
        extra_height = rect.h - h

        if self.horizontal_align == AlignLM.ALIGN_CENTER:
            x += extra_width * 0.5
        elif self.horizontal_align == AlignLM.ALIGN_RIGHT:
            x += extra_width
        elif self.horizontal_align == AlignLM.GROW_X:
            w = rect.w

        if self.vertical_align == AlignLM.ALIGN_MIDDLE:
            y += extra_height * 0.5
        elif self.vertical_align == AlignLM.ALIGN_TOP:
            y += extra_height
        elif self.vertical_align == AlignLM.GROW_Y:
            h = rect.h

        self.element.render(datatypes.Rectangle(x, y, w, h), data)
484860
public function render()
    {
        if ($this->getView() === null) {
            $this->setView(new TemplateView('controls/column_sorting'));
        }
        $this->getView()->mergeData([
            'order' => $this->getDirection(),
            'links' => $this->makeLinks()
        ]);
        return parent::render();
    }
230436
protected function render()
	{
		if (empty($this->getContent())) {
			$parsed = parse_ini_string($this->file->getContent(), true);
			$this->setContent(is_array($parsed) ? $parsed : []);
		}
	}
81733
def render(self, rect, data):
        """"""
        num_elements = len(self.elements)
        col_width = (rect.w-self.margin*(num_elements-1)) / float(num_elements)
        x = rect.x
        for element in self.elements:
            if element is not None:
                element.render(datatypes.Rectangle(
                        x, rect.y, col_width, rect.h
                        ), data)
            x += col_width + self.margin