// Text adds text to the current spinner
433261
func (w *Wow) Text(txt string) *Wow {
	w.mu.Lock()
	w.txt = txt
	w.mu.Unlock()
	return w
}
1084650
func TextRender(status int, data string) *Text {
	return &Text{
		Data: data,
		Head: &Head{
			Status:  status,
			Content: ContentText,
		},
	}
}
983942
func selLexText(l *selLexer) selStateFn {
	next := l.next()
	switch next {
	case '.':
		l.emit(selItemDot)
		return selLexProc
	case '[':
		l.emit(selItemLeftBrac)
		return selLexInsideBrac
	case ']':
		l.emit(selItemRightBrac)
		return selLexText
	case eof:
		break
	default:
		return selLexProc
	}
	if l.pos > l.start {
		l.emit(selItemProp)
	}
	l.emit(selItemEnd)
	return nil
}
170161
func (c *ChatMeMessageCall) Text(text string) *ChatMeMessageCall {
	c.text = text
	return c
}
656034
func (tm *TextMarshaler) Text(pb Message) string {
	var buf bytes.Buffer
	tm.Marshal(&buf, pb)
	return buf.String()
}
652897
func (s *Selection) Text() string {
	var buf bytes.Buffer

	// Slightly optimized vs calling Each: no single selection object created
	for _, n := range s.Nodes {
		buf.WriteString(getNodeText(n))
	}
	return buf.String()
}
551768
func (s *SynthesizeSpeechInput) SetText(v string) *SynthesizeSpeechInput {
	s.Text = &v
	return s
}
308638
func (r *Response) Text(text string) error {
	return r.Raw([]byte(text))
}
879266
func (s *Entity) SetText(v string) *Entity {
	s.Text = &v
	return s
}
1369792
func (c *TableCell) SetText(text string) *TableCell {
	c.Text = text
	return c
}
1304811
func (c *Ctx) Text(code int, s string) error {
	return c.TextBytes(code, []byte(s))
}
73171
func scanText(m *macro, p *parser) (stateFn, error) {
	for {

		r, err := m.next()

		if err != nil {
			m.output = append(m.output, m.input[m.start:m.pos])
			m.moveon()
			break
		}

		if r == '%' {
			// TODO(zaccone): exercise more with peek(),next(), back()
			m.output = append(m.output, m.input[m.start:m.prev])
			m.moveon()
			return scanPercent, nil
		}

	}
	return nil, nil
}
1279030
func (m *LevelMetadata) Text(enableColor bool) string {
	if enableColor {
		return m.ColorfulText
	}
	return m.RawText
}
1297086
func (g *Graph) _text(n int, buffer *bytes.Buffer, show bool) {

	sp := ""
	for i := 0; i < n; i++ {
		sp += "  "
	}

	/*
	   When printing strings with newlines, there are two possibilities:
	   block or quoted. Block is cleaner, but limited to leaf nodes. If the node
	   is not leaf (it has subnodes), then we are forced to print a multiline
	   quoted string.

	   If the string has no newlines but spaces or special characters, then the
	   same rule applies: quote those nodes that are non-leaf, print a block
	   otherways.

	   [!] Cannot print blocks at level 0? Or can we?
	*/

	s := "_"
	if g != nil {
		s = _string(g.This)
	}

	if strings.ContainsAny(s, "\n\r \t'\",()") {

		// print quoted, but not at level 0
		// Do not convert " to \" below if level==0 !
		if n > 0 {
			buffer.WriteString(sp[:len(sp)-1])
			buffer.WriteByte('"')
		}

		var c, cp byte

		cp = 0

		for i := 0; i < len(s); i++ {
			c = s[i] // byte, not rune
			if c == 13 {
				continue // ignore CR's
			} else if c == 10 {
				buffer.WriteByte('\n')
				buffer.WriteString(sp)
			} else if c == '"' && n > 0 {
				if cp != '\\' {
					buffer.WriteString("\\\"")
				}
			} else {
				buffer.WriteByte(c)
			}
			cp = c
		}

		if n > 0 {
			buffer.WriteString("\"")
		}
		buffer.WriteString("\n")
	} else {
		if len(s) == 0 && !show {
			n--
		} else {
			if len(s) == 0 && show {
				s = "_"
			}
			buffer.WriteString(sp)
			buffer.WriteString(s)
			buffer.WriteByte('\n')
		}
	}

	if g != nil {
		for i := 0; i < len(g.Out); i++ {
			node := g.Out[i]
			node._text(n+1, buffer, show)
		}
	}
}
1092151
func (gp *GoPdf) Text(text string) error {

	err := gp.curr.Font_ISubset.AddChars(text)
	if err != nil {
		return err
	}

	err = gp.getContent().AppendStreamText(text)
	if err != nil {
		return err
	}

	return nil
}
96613
func (e *TextEdit) SetText(text string) {
	e.text.Set([]rune(text))
}
445169
func (l *Literal) Text() (string, error) {
	if l.t != Text {
		return "", fmt.Errorf("literal.Text: literal is of type %v; cannot be converted to a string", l.t)
	}
	return l.v.(string), nil
}