// InitializeForRendering must be called before performing any rendering-related actions
170258
func (document *Document) InitializeForRendering(arguments string) {
	cArguments := C.CString(arguments)
	defer C.free(unsafe.Pointer(cArguments))
	C.initialize_for_rendering(document.handle, cArguments)
}
405033
func TextRendering(value textrendering.Type) Property {
	property := Property{propertyType: "text-rendering"}
	property.values = append(property.values, string(value))

	return property
}
682291
func (p *Provision) ValidateInitialization() error {
	if p.namespaceLister == nil {
		return fmt.Errorf("missing namespaceLister")
	}
	if p.client == nil {
		return fmt.Errorf("missing client")
	}
	return nil
}
495621
func (r *Renderer) RenderEvents(eventCh <-chan *TaskEvent) {
	for event := range eventCh {
		r.RenderEvent(event)
	}
}
1270975
func (p *priorityPlugin) ValidateInitialization() error {
	if p.client == nil {
		return fmt.Errorf("%s requires a client", PluginName)
	}
	if p.lister == nil {
		return fmt.Errorf("%s requires a lister", PluginName)
	}
	return nil
}
586696
func (a *claimDefaulterPlugin) ValidateInitialization() error {
	if a.lister == nil {
		return fmt.Errorf("missing lister")
	}
	return nil
}
357095
func (s *CreateSimulationApplicationVersionOutput) SetRenderingEngine(v *RenderingEngine) *CreateSimulationApplicationVersionOutput {
	s.RenderingEngine = v
	return s
}
1086690
func init() {
	AddInitEventHandler(func(typeOf Event, value interface{}) (responseOf EventResponse) {
		if typeOf == REVEL_BEFORE_MODULES_LOADED {
			RegisterTemplateLoader(GO_TEMPLATE, func(loader *TemplateLoader) (TemplateEngine, error) {
				// Set the template delimiters for the project if present, then split into left
				// and right delimiters around a space character

				TemplateDelims := Config.StringDefault("template.go.delimiters", "")
				var splitDelims []string
				if TemplateDelims != "" {
					splitDelims = strings.Split(TemplateDelims, " ")
					if len(splitDelims) != 2 {
						log.Fatalln("app.conf: Incorrect format for template.delimiters")
					}
				}

				return &GoEngine{
					loader:          loader,
					templateSet:     template.New("__root__").Funcs(TemplateFuncs),
					templatesByName: map[string]*GoTemplate{},
					splitDelims:     splitDelims,
				}, nil
			})
		}
		return
	})
}
270688
func init() {
	zeroArg = make([]reflect.Value, 0)
	zeroArgInterf = make([]interface{}, 0)
	trueInterf = true
	falseInterf = false
	nilInterf = nil
}
951847
func XMLRender(status int, indent bool, data interface{}, prefix []byte) *XML {
	return &XML{
		Indent: indent,
		Prefix: prefix,
		Data:   data,
		Head: &Head{
			Status:  status,
			Content: ContentXML,
		},
	}
}
304573
func (r DynamicRender) Instance(name string, data interface{}) render.Render {
	builder, ok := r[name]
	if !ok {
		panic(fmt.Sprintf("Dynamic template with name %s not found", name))
	}
	return render.HTML{
		Template: builder.buildTemplate(),
		Data:     data,
	}
}
737449
func (s *SequenceRenderer) Render(m ...string) trees.Markup {
	root := trees.NewElement(s.Tag, false)

	attrs.Class(strings.Join(s.Class, " ")).Apply(root)
	attrs.ID(s.ID).Apply(root)

	for _, st := range s.stack {
		st.Render(m...).Apply(root)
	}

	return root
}
837635
func RenderString(formatter Formatter, event *cue.Event) string {
	tmp := GetBuffer()
	defer ReleaseBuffer(tmp)

	formatter(tmp, event)
	return string(tmp.Bytes())
}
548977
func (c *Context) FrameBufferRenderBuffer(target, attachment, renderbufferTarget int, renderbuffer *js.Object) {
	c.Call("framebufferRenderBuffer", target, attachment, renderbufferTarget, renderbuffer)
}
709261
func init() {

	docsProvider := func() map[string]interface{} {
		docs := make(map[string]interface{})

		var chromaLexers []interface{}

		sort.Sort(lexers.Registry.Lexers)

		for _, l := range lexers.Registry.Lexers {

			config := l.Config()

			var filenames []string
			filenames = append(filenames, config.Filenames...)
			filenames = append(filenames, config.AliasFilenames...)

			aliases := config.Aliases

			for _, filename := range filenames {
				alias := strings.TrimSpace(strings.TrimPrefix(filepath.Ext(filename), "."))
				if alias != "" {
					aliases = append(aliases, alias)
				}
			}

			sort.Strings(aliases)
			aliases = UniqueStrings(aliases)

			lexerEntry := struct {
				Name    string
				Aliases []string
			}{
				config.Name,
				aliases,
			}

			chromaLexers = append(chromaLexers, lexerEntry)

			docs["lexers"] = chromaLexers
		}
		return docs

	}

	docshelper.AddDocProvider("chroma", docsProvider)
}
2161
func (renderer *Renderer) SetRenderTarget(texture *Texture) error {
	return errorFromInt(int(
		C.SDL_SetRenderTarget(renderer.cptr(), texture.cptr())))

}
1225101
func Render(doc []byte) []byte {
	renderer := NewRoffRenderer()

	return blackfriday.Run(doc,
		[]blackfriday.Option{blackfriday.WithRenderer(renderer),
			blackfriday.WithExtensions(renderer.GetExtensions())}...)
}