Print all fonts.

    :param text : input text
    :type text : str
    :param test: test flag
    :type test: bool
    :return: None
502316
def font_list(text="test", test=False):
    
    fonts = set(FONT_MAP.keys())
    if test:
        fonts = fonts - set(TEST_FILTERED_FONTS)
    for item in sorted(list(fonts)):
        print(str(item) + " : ")
        text_temp = text
        try:
            tprint(text_temp, str(item))
        except Exception:
            print(FONT_ENVIRONMENT_WARNING)
1284404
def text(self, text):
        
        ret = u"".join(text.content)
        if 'url' in text.properties:
            return u"`%s`_" % ret
        if 'bold' in text.properties:
            return u"**%s**" % ret
        if 'italic' in text.properties:
            return u"*%s*" % ret
        if 'sub' in text.properties:
            return ur"\ :sub:`%s`\ " % ret
        if 'super' in text.properties:
            return ur"\ :sup:`%s`\ " % ret
        return ret
934835
def debug_text_simple(self, text: str):
        
        self._debug_texts.append(self.to_debug_message(text))
548433
def println(self, text=""):
        
        if self.word_wrap:
            # find directives in complete text
            directives = ansi_color.find_directives(text, self)

            # strip ansi from text
            clean_text = ansi_color.strip_ansi_codes(text)

            # wrap clean text
            clean_lines = self.tw.wrap(clean_text)

            # print wrapped text
            index = 0
            for line in clean_lines:
                line_length = len(line)
                y = 0
                while y < line_length:
                    method, args = directives[index]
                    if method == self.putch:
                        y += 1
                    method(*args)
                    index += 1
                self.newline()
        else:
            self.puts(text)
            self.newline()
951707
def print_text(args, infilenames, outfilename=None):
    
    for infilename in infilenames:
        parsed_text = get_parsed_text(args, infilename)
        if parsed_text:
            for line in parsed_text:
                print(line)
            print('')
1373151
def run(self, text):
        
        for pp in self.pre_processors:
            text = pp.run(text)
        return text
367151
def setText( self, text ):
        
        super(XMultiTagItem, self).setText(text)
        
        metrics = QFontMetrics(self.font())
        
        hint = QSize(metrics.width(text) + 24, 18)
        self.setSizeHint(hint)
372406
def text(self, cls='current', retaintokenisation=False):
        

        #backward compatibility, old versions didn't have cls as first argument, so if a boolean is passed first we interpret it as the 2nd:
        if cls is True or cls is False:
            retaintokenisation = cls
            cls = 'current'

        s = ""
        for c in self.data:
            if s: s += "\n\n\n"
            try:
                s += c.text(cls, retaintokenisation)
            except NoSuchText:
                continue
        return s
346994
def fontChar(self, font, char):
        
        font_files = self._getCharFont(self._getFont(font), char)
        print('The character is {0}present in this font.'.format('' if font_files else 'not '))
679950
protected void print(String text) {
        String tableStart = format(PARAMETER_TABLE_START, PARAMETER_TABLE_START);
        String tableEnd = format(PARAMETER_TABLE_END, PARAMETER_TABLE_END);
        boolean containsTable = text.contains(tableStart) && text.contains(tableEnd);
        String textToPrint = containsTable ? transformPrintingTable(text, tableStart, tableEnd) : text;
        print(output, textToPrint
                .replace(format(PARAMETER_VALUE_START, PARAMETER_VALUE_START), format("parameterValueStart", EMPTY))
                .replace(format(PARAMETER_VALUE_END, PARAMETER_VALUE_END), format("parameterValueEnd", EMPTY))
                .replace(format(PARAMETER_VALUE_NEWLINE, PARAMETER_VALUE_NEWLINE), format("parameterValueNewline", NL)));
    }
1010704
def print_difftext(text, other=None):
    
    if other is not None:
        # hack
        text = util_str.difftext(text, other)
    colortext = util_str.color_diff_text(text)
    try:
        print(colortext)
    except UnicodeEncodeError as ex:  # NOQA
        import unicodedata
        colortext = unicodedata.normalize('NFKD', colortext).encode('ascii', 'ignore')
        print(colortext)
525701
def render(self, flags: Flags) -> Text:
        
        return random.choice(self.best_for_flags(flags)).value
1120021
def chars(self, font, block):
        
        if font:
            font_files = self._getFont(font)
        else:
            font_files = fc.query()
        code_points = self._getFontChars(font_files)

        if not block:
            blocks = all_blocks
            ranges_column = map(itemgetter(3), blocks)
            overlapped = Ranges(code_points).getOverlappedList(ranges_column)
        else:
            blocks = [block]
            overlapped = [Ranges(code_points).getOverlapped(block[3])]

        if self._display['group']:
            char_count = block_count = 0
            for i, block in enumerate(blocks):
                o_count = len(overlapped[i])
                if o_count:
                    block_count += 1
                    char_count += o_count
                    total = sum(len(r) for r in block[3])
                    percent = 0 if total == 0 else o_count / total
                    print("{0:>6}  {1:47} {2:>4.0%} ({3}/{4})".format(block[0], block[2], percent, o_count, total))
                    if self._display['list']:
                        for point in overlapped[i]:
                            self._charInfo(point, padding=9)
            self._charSummary(char_count, block_count)
        else:
            for point in code_points:
                self._charInfo(point, padding=7)
            self._charSummary(len(code_points))
912651
def setLabel( self, text ):
        
        if ( self._editor and hasattr(self._editor, 'setLabel') ):
            self._editor.setLabel(text)
            return True
        return False
1020491
def supportedChars(*tests):
    
    for test in tests:
        try:
            test.encode(sys.stdout.encoding)
            return test
        except UnicodeEncodeError:
            pass
    return '?' * len(tests[0])
94959
def render(self, text, add_header=False):
        

        html = mark_text(text, self.aesthetics, self.rules)
        html = html.replace('\n', '<br/>')
        if add_header:
            html = '\n'.join([HEADER, self.css, MIDDLE, html, FOOTER])
        #print('\n'.join((HEADER, self.css, MIDDLE, html, FOOTER)))
        return html
795474
def debug(self, text):
		
		self.logger.debug("{}{}".format(self.message_prefix, text))