Returns the read only for this widget from the editor.
        Differs per type, not all types support read only.
        
        :param      text | <str>
321695
def isReadOnly( self ):
        
        if ( self._editor and hasattr(self._editor, 'isReadOnly') ):
            return self._editor.isReadOnly()
        return False
1333721
def setText(self, text):
        
        super(XTextEdit, self).setText(projex.text.toAscii(text))
885372
def setText( self, text ):
        
        if text is None:
            text = ''
        
        super(XLineEdit, self).setText(projex.text.encoded(self.formatText(text), self.encoding()))
1300065
def field2read_only(self, field, **kwargs):
        
        attributes = {}
        if field.dump_only:
            attributes["readOnly"] = True
        return attributes
513383
def from_text(cls, text: str):
        

        eidosProcessor = process_text(text)
        return cls.from_statements(eidosProcessor.statements)
65780
def clean(text, cls=None, **kwargs):
    
    cls = cls or Scrubber
    scrubber = cls()
    return scrubber.clean(text, **kwargs)
862922
def read(self):
        
        lines = self.readlines()
        if lines:
            try:
                return ''.join(lines)
            except TypeError:
                return ''.join(force_text(line) for line in lines)
        else:
            return None
935700
def eof():
    ''''''
    @Parser
    def eof_parser(text, index=0):
        if index >= len(text):
            return Value.success(index, None)
        else:
            return Value.failure(index, 'EOF')
    return eof_parser
1275552
def from_text(text):
    

    if text.isdigit():
        total = long(text)
    else:
        if not text[0].isdigit():
            raise BadTTL
        total = 0L
        current = 0L
        for c in text:
            if c.isdigit():
                current *= 10
                current += long(c)
            else:
                c = c.lower()
                if c == 'w':
                    total += current * 604800L
                elif c == 'd':
                    total += current * 86400L
                elif c == 'h':
                    total += current * 3600L
                elif c == 'm':
                    total += current * 60L
                elif c == 's':
                    total += current
                else:
                    raise BadTTL("unknown unit '%s'" % c)
                current = 0
        if not current == 0:
            raise BadTTL("trailing integer")
    if total < 0L or total > 2147483647L:
        raise BadTTL("TTL should be between 0 and 2^31 - 1 (inclusive)")
    return total
888604
public VisDialog text (String text) {
		if (skin == null)
			throw new IllegalStateException("This method may only be used if the dialog was constructed with a Skin.");
		return text(text, skin.get(LabelStyle.class));
	}
865017
def text(self):
        
        data = self.content
        return data.decode(self.encoding or 'utf-8') if data else ''
1041226
def get_text(self):
        
        if self._multiline: return str(self._widget.toPlainText())
        else:               return str(self._widget.text())
94257
def extract(self, text: str) -> List[Extraction]:
        

        doc = self._parser(text)

        extractions = list()
        for sent in doc.sents:
            this_extraction = Extraction(value=sent.text,
                                         extractor_name=self.name,
                                         start_token=sent[0],
                                         end_token=sent[-1],
                                         start_char=sent.text[0],
                                         end_char=sent.text[-1])
            extractions.append(this_extraction)

        return extractions
604535
def _get_text(self, text):
        
        animation = self._animation
        stripped_text = text.strip()

        # Check which frame of the animation is the widest
        max_spinner_length = max([len(i) for i in self._spinner['frames']])

        # Subtract to the current terminal size the max spinner length
        # (-1 to leave room for the extra space between spinner and text)
        terminal_width = get_terminal_columns() - max_spinner_length - 1
        text_length = len(stripped_text)

        frames = []

        if terminal_width < text_length and animation:
            if animation == 'bounce':
                """
                Make the text bounce back and forth
                """
                for x in range(0, text_length - terminal_width + 1):
                    frames.append(stripped_text[x:terminal_width + x])
                frames.extend(list(reversed(frames)))
            elif 'marquee':
                """
                Make the text scroll like a marquee
                """
                stripped_text = stripped_text + ' ' + stripped_text[:terminal_width]
                for x in range(0, text_length + 1):
                    frames.append(stripped_text[x:terminal_width + x])
        elif terminal_width < text_length and not animation:
            # Add ellipsis if text is larger than terminal width and no animation was specified
            frames = [stripped_text[:terminal_width - 6] + ' (...)']
        else:
            frames = [stripped_text]

        return {
            'original': text,
            'frames': frames
        }
869909
def setHint(self, text):
        
        texts = nativestring(text).split(' ')
        
        for i, text in enumerate(texts):
            editor = self.editorAt(i)
            if not editor:
                break
            
            editor.setHint(text)
181610
def eval(self, text):
        
        assert is_text_string(text)
        try:
            return eval(text, self.locals), True
        except:
            return None, False
482592
def get_toc(text):
    
    mkd.convert(text)
    toc = mkd.toc
    mkd.reset()
    return toc