render a slider widget
494807
function() {
            
      this.sliderbg = inputEx.cn('div', {id: YAHOO.util.Dom.generateId(), className: 'inputEx-SliderField-bg'});
      this.sliderthumb = inputEx.cn('div', {className: 'inputEx-SliderField-thumb'} );      
      this.sliderbg.appendChild(this.sliderthumb);
      this.fieldContainer.appendChild(this.sliderbg);
      
      if(this.options.displayValue) {
         this.valueDisplay = inputEx.cn('div', {className: 'inputEx-SliderField-value'}, null, String(this.options.minValue) );
         this.fieldContainer.appendChild(this.valueDisplay);
      }
      
      this.fieldContainer.appendChild( inputEx.cn('div',null,{clear: 'both'}) );
            
      this.slider = YAHOO.widget.Slider.getHorizSlider(this.sliderbg, this.sliderthumb, 0,100);
   }
826526
function render() {
  const wicked = bewitched.get(this);
  const args = tta.apply(null, arguments);
  if (wicked && wicked.template === args[0]) {
    wicked.tagger.apply(null, args);
  } else {
    upgrade.apply(this, args);
  }
  return this;
}
279295
function() {

		 // Render the help panel
	    this.renderHelpPanel();

	    /**
	     * @property layout
	     * @type {YAHOO.widget.Layout}
	     */
	    this.layout = new widget.Layout(this.el, this.options.layoutOptions);
	    this.layout.render();

		 // Right accordion
	    this.renderPropertiesAccordion();

	    // Render buttons
	    this.renderButtons();

	 	 // Saved status
		 this.renderSavedStatus();

	    // Properties Form
	    this.renderPropertiesForm();

  }
680117
function render(output, data, node) {
        // data is a model id
        var manager = Jupyter.notebook && Jupyter.notebook.kernel && Jupyter.notebook.kernel.widget_manager;
        if (!manager) {
            node.textContent = "Error rendering Jupyter widget: missing widget manager";
            return;
        }

        // Missing model id means the view was removed. Hide this element.
        if (data.model_id === '') {
            node.style.display = 'none';
            return;
        }

        var model = manager.get_model(data.model_id);
        if (model) {
            model.then(function(model) {
                return manager.display_model(void 0, model, {output: output});
            }).then(function(view) {
                var id = view.cid;
                output._jupyterWidgetViews = output._jupyterWidgetViews || [];
                output._jupyterWidgetViews.push(id);
                views[id] = view;
                PhosphorWidget.Widget.attach(view.pWidget, node);

                // Make the node completely disappear if the view is removed.
                view.once('remove', () => {
                    // Since we have a mutable reference to the data, delete the
                    // model id to indicate the view is removed.
                    data.model_id = '';
                    node.style.display = 'none';
                })
            });
        } else {
            node.textContent = 'A Jupyter widget could not be displayed because the widget state could not be found. This could happen if the kernel storing the widget is no longer available, or if the widget state was not saved in the notebook. You may be able to create the widget by running the appropriate cells.';
        }
    }
1031337
function Renderer(options) {
  var defaults = {
    headers: {
      included: true,
      downcase: true,
      upcase: true
    },

    delimiter: 'tab',
    decimalSign: 'comma',
    outputDataType: 'json',
    columnDelimiter: "\t",
    rowDelimiter: '\n',

    inputHeader: {},
    outputHeader: {},
    dataSelect: {},

    outputText: '',

    newline: '\n',
    indent: '  ',

    commentLine: '//',
    commentLineEnd: '',
    tableName: 'converter',

    useUnderscores: true,
    includeWhiteSpace: true,
    useTabsForIndent: false
  };

  this.options = merge({}, defaults, options);
  if (this.options.includeWhiteSpace) {
    this.options.newline = '\n';
  } else {
    this.options.indent = '';
    this.options.newline = '';
  }
}
659447
function ($slider) {
    var data = $slider.data();

    var $track = data.$track;
    var $fill = data.$fill;
    var $thumb = data.$thumb;
    var $input = data.$input;
    var min = data.min;
    var max = data.max;
    var isDisabled = data.disabled;
    var isDiscrete = data.discrete;
    var $thumbText = data.$thumbText;
    var value = $input.val();
    var percent = (value - min) / (max - min) * 100;

    $fill.width(percent + '%');
    $track.width((100 - percent) + '%');

    if (isDisabled) {
      $fill.css('padding-right', '6px');
      $track.css('padding-left', '6px');
    }

    $thumb.css('left', percent + '%');

    if (isDiscrete) {
      $thumbText.text(value);
    }

    $slider[parseFloat(percent) === 0 ? 'addClass' : 'removeClass']('mdui-slider-zero');
  }
645051
def render(self, *args, **kwargs):
        """"""
        if not self.childs and "href" in self.attrs:
            return self.clone()(self.attrs["href"]).render(*args, **kwargs)
        return super().render(*args, **kwargs)
751578
def RenderWidget(self):
        """"""
        t = self.type
        if t == int:
            ret = QSpinBox()
            ret.setMaximum(999999999)
            ret.setValue(self.value)
        elif t == float:
            ret = QLineEdit()
            ret.setText(str(self.value))
        elif t == bool:
            ret = QCheckBox()
            ret.setChecked(self.value)
        else:  # str, list left
            ret = QLineEdit()
            ret.setText(str(self.value))

        if self.toolTip is not None:
            ret.setToolTip(self.toolTip)

        self.widget = ret
        return ret
1004230
public function renderWidget( $config = [] ) {

		if( !isset( $this->slug ) ) {

            throw new InvalidConfigException( "The slider slug option is required." );
        }

		$this->model = $this->modelService->getBySlug( $this->slug );

		$model	= $this->model;
		$items 	= [];

		if( !isset( $model ) ) {

			return "<div>Slider having slug set to $this->slug does not exist. Please create it via admin.</div>";
        }

		// Configure
		$this->configureSlider();

		// Views Path
		$slidePath = "$this->template/slide";

		// Generate Slides Html

		$slides = $model->slides;

        foreach( $slides as $slide ) {

            $items[] = $this->render( $slidePath, [
				'widget' => $this, 'fxOptions' => $this->fxOptions, 'slide' => $slide,
				'genericContent' => $this->genericContent
			]);
        }

		// Register JS
		$modelOptions	= json_encode( $this->fxOptions );
		$modelJs		= "jQuery( '.fx-" . $model->slug . "' ).foxslider( $modelOptions );";

		$this->getView()->registerJs( $modelJs, View::POS_READY );

		$htmlContent = implode( "\n", $items );

		if( $this->wrap ) {

			// Apply model options - Overrides widget and template options
			$htmlOptions = json_decode( $model->htmlOptions, true );

			$options = !empty( $htmlOptions ) ? ArrayHelper::merge( $this->options, $htmlOptions ) : $this->options;

			//$options[ 'id' ] = "fxs-{$model->slug}";

			$classOption = isset( $options[ 'class' ] ) ? $options[ 'class' ] : null;
			$classOption = !empty( $classOption ) ? "fx $classOption fx-{$model->slug}" : "fx fx-{$model->slug}";

			$options[ 'class' ] = $classOption;

			return Html::tag( 'div', $htmlContent, $options );
		}

		return $htmlContent;
    }
1317373
function Renderer(options) {
  options = options || {};
  this.MD   = new MDRenderer(options);
  this.CGMD = new CGMDRenderer(new MDRenderer(options));

  return this;
}
728150
public function renderPaginator()
    {
        $paginator = $this->getTable()->getSource()->getPaginator();
        $paginator->setView($this->getRenderer());
        $res = $this->getRenderer()->paginationControl($paginator, 'Sliding', 'paginator-slide');
        return $res;
    }
570385
function render() {
  var content = $($.parseHTML(template));
  var compiler = Handlebars.compile(content.filter("#layout").html());

  Handlebars.registerPartial({
    leftPanel: content.filter("#left-panel").html(),
    rightPanel: content.filter("#right-panel").html(),
    transactionList: content.filter("#transaction-list").html(),
    transactionDetails: content.filter("#transaction-details").html(),
    transactionOther: content.filter("#transaction-other").html(),
  });

  // Adds selected class to selected transaction item.
  Handlebars.registerHelper('isSelected', function(options) {
    var resp =
      (this.business === dataView.selectedTransaction.business) ?
      "selected" : "";
    return options.fn(resp);
  });

  // Returns fake detail monthly total.
  Handlebars.registerHelper('monthlyTotal', function(options) {
    var total = toCurrency(parseFloat(this.selectedTransaction.amount) * 12);
    return options.fn(total);
  });

  // Returns fake detail yearly total.
  Handlebars.registerHelper('yearlyTotal', function(options) {
    var total = toCurrency(parseFloat(this.selectedTransaction.amount) * 40);
    return options.fn(total);
  });

  var html = compiler(dataView);
  $("#demo-app").html(html);

  addClickHandler();
}
25851
function Renderer(options = {}) {
    if (!(this instanceof Renderer)) {
        return new Renderer(options);
    }
    var o = (this.options = Object.assign({}, defaults, options));

    // custom handlebars instance
    this.handlebars = handlebars.create();

    // register global helpers/partials
    if (o.helpers) this.helper(o.helpers);
    if (o.partials) this.partial(o.partials);

    // enabling caching (via lru-cache)
    if (o.cache) {
        this.cache = new Cache({ max: 100 });
    }
}
93369
public function renderField()
    {
        list($name, $id) = $this->resolveNameID();

        if ($this->hasModel()) {
            echo CHtml::activeHiddenField($this->model, $this->attribute, $this->htmlOptions);
        } else {
            echo CHtml::hiddenField($name, $this->value, $this->htmlOptions);
        }

        echo '<div id="slider_' . $id . '"></div>';
    }
1065221
def render(self, name, value, attrs=None, multi=False, renderer=None):
        
        DJANGO_111_OR_UP = (VERSION[0] == 1 and VERSION[1] >= 11) or (
            VERSION[0] >= 2
        )
        if DJANGO_111_OR_UP:
            return super(DynamicRawIDWidget, self).render(
                name, value, attrs, renderer=renderer
            )

        if attrs is None:
            attrs = {}

        related_url = reverse(
            'admin:{0}_{1}_changelist'.format(
                self.rel.to._meta.app_label,
                self.rel.to._meta.object_name.lower(),
            ),
            current_app=self.admin_site.name,
        )

        params = self.url_parameters()
        if params:
            url = u'?' + u'&'.join(
                [u'{0}={1}'.format(k, v) for k, v in params.items()]
            )
        else:
            url = u''
        if "class" not in attrs:
            attrs[
                'class'
            ] = (
                'vForeignKeyRawIdAdminField'
            )  # The JavaScript looks for this hook.
        app_name = self.rel.to._meta.app_label.strip()
        model_name = self.rel.to._meta.object_name.lower().strip()
        hidden_input = super(widgets.ForeignKeyRawIdWidget, self).render(
            name, value, attrs
        )

        extra_context = {
            'hidden_input': hidden_input,
            'name': name,
            'app_name': app_name,
            'model_name': model_name,
            'related_url': related_url,
            'url': url,
        }
        return render_to_string(
            'dynamic_raw_id/admin/widgets/dynamic_raw_id_field.html',
            extra_context,
        )
1349449
def render(self, type, rerender=False):
        """"""
        for child in self.children:
            child.render(type, rerender)
1014092
public function renderTemplate()
    {
        $options = array(
            'id' => $this->htmlOptions['id'] . '-gallery',
            'class' => 'blueimp-gallery'
        );
        if ($this->displayControls) {
            TbHtml::addCssClass('blueimp-gallery-controls', $options);
        }
        echo CHtml::openTag('div', $options);
        echo '<div class="slides"></div>
		<h3 class="title"></h3>
		<a class="prev">‹</a>
		<a class="next">›</a>
		<a class="close">×</a>
		<a class="play-pause"></a>
		<ol class="indicator"></ol>';
        echo CHtml::closeTag('div');
    }