Back to index

moin  1.9.0~rc2
Public Member Functions | Public Attributes | Static Public Attributes | Private Member Functions | Private Attributes | Static Private Attributes
MoinMoin.formatter.text_html.Formatter Class Reference
Inheritance diagram for MoinMoin.formatter.text_html.Formatter:
Inheritance graph
[legend]
Collaboration diagram for MoinMoin.formatter.text_html.Formatter:
Collaboration graph
[legend]

List of all members.

Public Member Functions

def __init__
def startContent
def endContent
def lang
def pagelink
def interwikilink
def url
def anchordef
def line_anchordef
def anchorlink
def line_anchorlink
def attachment_link
def attachment_image
def attachment_drawing
def strong
def emphasis
def underline
def highlight
def sup
def sub
def strike
def code
def small
def big
def preformatted
def code_area
def code_line
def code_token
def linebreak
def paragraph
def rule
def icon
def image
def transclusion
def transclusion_param
def number_list
def bullet_list
def listitem
def definition_list
def definition_term
def definition_desc
def heading
def table
def table_row
def table_cell
def text
def escapedText
def rawHTML
def sysmsg
def div
def span
def sanitize_to_id
def set_highlight_re
def setPage
def startDocument
def endDocument
def startContent
def endContent
def url
def attachment_link
def attachment_inlined
def smiley
def nowikiword
def code_area
def definition_term
def macro
def parser
def comment
def make_id_unique
def qualify_id

Public Attributes

 pagelink_preclosed
 request
 cfg
 no_magic
 pagelinks
 in_p
 in_pre
 page

Static Public Attributes

string hardspace = ' '
string indentspace = ' '
 smiley = icon

Private Member Functions

def _langAttr
def _formatAttributes
def _open
def _close
def _text
def _indent_spaces
def _newline
def _checkTableAttr

Private Attributes

 _indent_level
 _in_code
 _in_code_area
 _in_code_line
 _code_area_js
 _code_area_state
 _show_section_numbers
 _is_included
 _base_depth

Static Private Attributes

string _toggleLineNumbersScript
dictionary _allowed_table_attrs

Detailed Description

    Send HTML data.

Definition at line 175 of file text_html.py.


Constructor & Destructor Documentation

def MoinMoin.formatter.text_html.Formatter.__init__ (   self,
  request,
  kw 
)

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 183 of file text_html.py.

00183 
00184     def __init__(self, request, **kw):
00185         FormatterBase.__init__(self, request, **kw)
00186         self._indent_level = 0
00187 
00188         self._in_code = 0 # used by text_gedit
00189         self._in_code_area = 0
00190         self._in_code_line = 0
00191         self._code_area_js = 0
00192         self._code_area_state = ['', 0, -1, -1, 0]
00193         self._show_section_numbers = None
00194         self.pagelink_preclosed = False
00195         self._is_included = kw.get('is_included', False)
00196         self.request = request
00197         self.cfg = request.cfg
00198         self.no_magic = kw.get('no_magic', False) # disabled tag auto closing
00199 
00200         if not hasattr(request, '_fmt_hd_counters'):
00201             request._fmt_hd_counters = []


Member Function Documentation

def MoinMoin.formatter.text_html.Formatter._checkTableAttr (   self,
  attrs,
  prefix 
) [private]
Check table attributes

Convert from wikitable attributes to html 4 attributes.

@param attrs: attribute dict
@param prefix: used in wiki table attributes
@rtype: dict
@return: valid table attributes

Reimplemented in MoinMoin.formatter.text_gedit.Formatter.

Definition at line 1187 of file text_html.py.

01187 
01188     def _checkTableAttr(self, attrs, prefix):
01189         """ Check table attributes
01190 
01191         Convert from wikitable attributes to html 4 attributes.
01192 
01193         @param attrs: attribute dict
01194         @param prefix: used in wiki table attributes
01195         @rtype: dict
01196         @return: valid table attributes
01197         """
01198         if not attrs:
01199             return {}
01200 
01201         result = {}
01202         s = [] # we collect synthesized style in s
01203         for key, val in attrs.items():
01204             # Ignore keys that don't start with prefix
01205             if prefix and key[:len(prefix)] != prefix:
01206                 continue
01207             key = key[len(prefix):]
01208             val = val.strip('"')
01209             # remove invalid attrs from dict and synthesize style
01210             if key == 'width':
01211                 s.append("width: %s" % val)
01212             elif key == 'height':
01213                 s.append("height: %s" % val)
01214             elif key == 'bgcolor':
01215                 s.append("background-color: %s" % val)
01216             elif key == 'align':
01217                 s.append("text-align: %s" % val)
01218             elif key == 'valign':
01219                 s.append("vertical-align: %s" % val)
01220             # Ignore unknown keys
01221             if key not in self._allowed_table_attrs[prefix]:
01222                 continue
01223             result[key] = val
01224         st = result.get('style', '').split(';')
01225         st = '; '.join(st + s)
01226         st = st.strip(';')
01227         st = st.strip()
01228         if not st:
01229             try:
01230                 del result['style'] # avoid empty style attr
01231             except:
01232                 pass
01233         else:
01234             result['style'] = st
01235         #logging.debug("_checkTableAttr returns %r" % result)
01236         return result
01237 

Here is the caller graph for this function:

def MoinMoin.formatter.text_html.Formatter._close (   self,
  tag,
  newline = False 
) [private]
Close tag (INTERNAL USE BY HTML FORMATTER ONLY!)

@param tag: html tag, string
@param newline: render tag so following data is on a separate line
@rtype: string
@return: closing tag as a string

Definition at line 377 of file text_html.py.

00377 
00378     def _close(self, tag, newline=False):
00379         """ Close tag (INTERNAL USE BY HTML FORMATTER ONLY!)
00380 
00381         @param tag: html tag, string
00382         @param newline: render tag so following data is on a separate line
00383         @rtype: string
00384         @return: closing tag as a string
00385         """
00386         if tag in _self_closing_tags or (tag in _auto_closing_tags and not self.no_magic):
00387             # This tag was already closed
00388             tagstr = ''
00389         elif tag in _blocks:
00390             # Block elements
00391             result = []
00392             if newline:
00393                 result.append(self._newline())
00394             result.append('</%s>' % (tag))
00395             tagstr = ''.join(result)
00396         else:
00397             # Inline elements
00398             tagstr = '</%s>' % tag
00399 
00400         if newline:
00401             tagstr += self._newline()
00402         return tagstr

Here is the call graph for this function:

Here is the caller graph for this function:

def MoinMoin.formatter.text_html.Formatter._formatAttributes (   self,
  attr = None,
  allowed_attrs = None,
  kw 
) [private]
Return HTML attributes formatted as a single string. (INTERNAL USE BY HTML FORMATTER ONLY!)

@param attr: dict containing keys and values
@param allowed_attrs: A list of allowable attribute names
@param kw: other arbitrary attributes expressed as keyword arguments.
@rtype: string
@return: formated attributes or empty string

The attributes and their values can either be given in the
'attr' dictionary, or as extra keyword arguments.  They are
both merged together.  See the function
rewrite_attribute_name() for special notes on how to name
attributes.

Setting a value to None rather than a string (or string
coercible) will remove that attribute from the list.

If the list of allowed_attrs is provided, then an error is
raised if an HTML attribute is encountered that is not in that
list (or is not a common attribute which is always allowed or
is not in another XML namespace using the double-underscore
syntax).

Definition at line 231 of file text_html.py.

00231 
00232     def _formatAttributes(self, attr=None, allowed_attrs=None, **kw):
00233         """ Return HTML attributes formatted as a single string. (INTERNAL USE BY HTML FORMATTER ONLY!)
00234 
00235         @param attr: dict containing keys and values
00236         @param allowed_attrs: A list of allowable attribute names
00237         @param kw: other arbitrary attributes expressed as keyword arguments.
00238         @rtype: string
00239         @return: formated attributes or empty string
00240 
00241         The attributes and their values can either be given in the
00242         'attr' dictionary, or as extra keyword arguments.  They are
00243         both merged together.  See the function
00244         rewrite_attribute_name() for special notes on how to name
00245         attributes.
00246 
00247         Setting a value to None rather than a string (or string
00248         coercible) will remove that attribute from the list.
00249 
00250         If the list of allowed_attrs is provided, then an error is
00251         raised if an HTML attribute is encountered that is not in that
00252         list (or is not a common attribute which is always allowed or
00253         is not in another XML namespace using the double-underscore
00254         syntax).
00255         """
00256 
00257         # Merge the attr dict and kw dict into a single attributes
00258         # dictionary (rewriting any attribute names, extracting
00259         # namespaces, and merging some values like css classes).
00260         attributes = {} # dict of key=(namespace,name): value=attribute_value
00261         if attr:
00262             for a, v in attr.items():
00263                 a_ns, a_name = rewrite_attribute_name(a)
00264                 extend_attribute_dictionary(attributes, a_ns, a_name, v)
00265         if kw:
00266             for a, v in kw.items():
00267                 a_ns, a_name = rewrite_attribute_name(a)
00268                 extend_attribute_dictionary(attributes, a_ns, a_name, v)
00269 
00270         # Add title attribute if missing, but it has an alt.
00271         if ('html', 'alt') in attributes and ('html', 'title') not in attributes:
00272             attributes[('html', 'title')] = attributes[('html', 'alt')]
00273 
00274         # Force both lang and xml:lang to be present and identical if
00275         # either exists.  The lang takes precedence over xml:lang if
00276         # both exist.
00277         #if ('html', 'lang') in attributes:
00278         #    attributes[('xml', 'lang')] = attributes[('html', 'lang')]
00279         #elif ('xml', 'lang') in attributes:
00280         #    attributes[('html', 'lang')] = attributes[('xml', 'lang')]
00281 
00282         # Check all the HTML attributes to see if they are known and
00283         # allowed.  Ignore attributes if in non-HTML namespaces.
00284         if allowed_attrs:
00285             for name in [key[1] for key in attributes if key[0] == 'html']:
00286                 if name in _common_attributes or name in allowed_attrs:
00287                     pass
00288                 elif name.startswith('on'):
00289                     pass  # Too many event handlers to enumerate, just let them all pass.
00290                 else:
00291                     # Unknown or unallowed attribute.
00292                     err = 'Illegal HTML attribute "%s" passed to formatter' % name
00293                     raise ValueError(err)
00294 
00295         # Finally, format them all as a single string.
00296         if attributes:
00297             # Construct a formatted string containing all attributes
00298             # with their values escaped.  Any html:* namespace
00299             # attributes drop the namespace prefix.  We build this by
00300             # separating the attributes into three categories:
00301             #
00302             #  * Those without any namespace (should only be xmlns attributes)
00303             #  * Those in the HTML namespace (we drop the html: prefix for these)
00304             #  * Those in any other non-HTML namespace, including xml:
00305 
00306             xmlnslist = ['%s="%s"' % (k[1], wikiutil.escape(v, 1))
00307                          for k, v in attributes.items() if not k[0]]
00308             htmllist = ['%s="%s"' % (k[1], wikiutil.escape(v, 1))
00309                         for k, v in attributes.items() if k[0] == 'html']
00310             otherlist = ['%s:%s="%s"' % (k[0], k[1], wikiutil.escape(v, 1))
00311                          for k, v in attributes.items() if k[0] and k[0] != 'html']
00312 
00313             # Join all these lists together in a space-separated string.  Also
00314             # prefix the whole thing with a space too.
00315             htmllist.sort()
00316             otherlist.sort()
00317             all = [''] + xmlnslist + htmllist + otherlist
00318             return ' '.join(all)
00319         return ''

Here is the call graph for this function:

Here is the caller graph for this function:

Returns space(s) for indenting the html source so list nesting is easy to read.

Note that this mostly works, but because of caching may not always be accurate.

Definition at line 949 of file text_html.py.

00949 
00950     def _indent_spaces(self):
00951         """Returns space(s) for indenting the html source so list nesting is easy to read.
00952 
00953         Note that this mostly works, but because of caching may not always be accurate."""
00954         if prettyprint:
00955             return self.indentspace * self._indent_level
00956         else:
00957             return ''

Here is the caller graph for this function:

def MoinMoin.formatter.text_html.Formatter._langAttr (   self,
  lang = None 
) [private]
Return lang and dir attribute
(INTERNAL USE BY HTML FORMATTER ONLY!)

Must be used on all block elements - div, p, table, etc.
@param lang: if defined, will return attributes for lang. if not
    defined, will return attributes only if the current lang is
    different from the content lang.
@rtype: dict
@return: language attributes

Definition at line 208 of file text_html.py.

00208 
00209     def _langAttr(self, lang=None):
00210         """ Return lang and dir attribute
00211         (INTERNAL USE BY HTML FORMATTER ONLY!)
00212 
00213         Must be used on all block elements - div, p, table, etc.
00214         @param lang: if defined, will return attributes for lang. if not
00215             defined, will return attributes only if the current lang is
00216             different from the content lang.
00217         @rtype: dict
00218         @return: language attributes
00219         """
00220         if not lang:
00221             lang = self.request.current_lang
00222             # Actions that generate content in user language should change
00223             # the content lang from the default defined in cfg.
00224             if lang == self.request.content_lang:
00225                 # lang is inherited from content div
00226                 return {}
00227 
00228         #attr = {'xml:lang': lang, 'lang': lang, 'dir': i18n.getDirection(lang),}
00229         attr = {'lang': lang, 'dir': i18n.getDirection(lang), }
00230         return attr

Here is the caller graph for this function:

Returns the whitespace for starting a new html source line, properly indented.

Definition at line 958 of file text_html.py.

00958 
00959     def _newline(self):
00960         """Returns the whitespace for starting a new html source line, properly indented."""
00961         if prettyprint:
00962             return '\n' + self._indent_spaces()
00963         else:
00964             return ''

Here is the call graph for this function:

Here is the caller graph for this function:

def MoinMoin.formatter.text_html.Formatter._open (   self,
  tag,
  newline = False,
  attr = None,
  allowed_attrs = None,
  is_unique = False,
  kw 
) [private]
Open a tag with optional attributes (INTERNAL USE BY HTML FORMATTER ONLY!)

@param tag: html tag, string
@param newline: render tag so following data is on a separate line
@param attr: dict with tag attributes
@param allowed_attrs: list of allowed attributes for this element
@param is_unique: ID is already unique
@param kw: arbitrary attributes and values
@rtype: string ?
@return: open tag with attributes as a string

Definition at line 321 of file text_html.py.

00321 
00322               is_unique=False, **kw):
00323         """ Open a tag with optional attributes (INTERNAL USE BY HTML FORMATTER ONLY!)
00324 
00325         @param tag: html tag, string
00326         @param newline: render tag so following data is on a separate line
00327         @param attr: dict with tag attributes
00328         @param allowed_attrs: list of allowed attributes for this element
00329         @param is_unique: ID is already unique
00330         @param kw: arbitrary attributes and values
00331         @rtype: string ?
00332         @return: open tag with attributes as a string
00333         """
00334         # If it is self-closing, then don't expect a closing tag later on.
00335         is_self_closing = (tag in _self_closing_tags) and ' /' or ''
00336 
00337         # make ID unique
00338         id = None
00339         if not is_unique:
00340             if attr and 'id' in attr:
00341                 id = self.make_id_unique(attr['id'])
00342                 id = self.qualify_id(id)
00343                 attr['id'] = id
00344             if 'id' in kw:
00345                 id = self.make_id_unique(kw['id'])
00346                 id = self.qualify_id(id)
00347                 kw['id'] = id
00348         else:
00349             if attr and 'id' in attr:
00350                 id = attr['id']
00351             if 'id' in kw:
00352                 id = kw['id']
00353 
00354         if tag in _blocks:
00355             # Block elements
00356             result = []
00357 
00358             # Add language attributes, but let caller overide the default
00359             attributes = self._langAttr()
00360             if attr:
00361                 attributes.update(attr)
00362 
00363             # Format
00364             attributes = self._formatAttributes(attributes, allowed_attrs=allowed_attrs, **kw)
00365             result.append('<%s%s%s>' % (tag, attributes, is_self_closing))
00366             if newline:
00367                 result.append(self._newline())
00368             if _id_debug and id:
00369                 result.append('(%s) ' % id)
00370             tagstr = ''.join(result)
00371         else:
00372             # Inline elements
00373             tagstr = '<%s%s%s>' % (tag,
00374                                       self._formatAttributes(attr, allowed_attrs, **kw),
00375                                       is_self_closing)
00376         return tagstr

Here is the call graph for this function:

def MoinMoin.formatter.text_html.Formatter._text (   self,
  text 
) [private]

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 670 of file text_html.py.

00670 
00671     def _text(self, text):
00672         text = wikiutil.escape(text)
00673         if self._in_code:
00674             text = text.replace(' ', self.hardspace)
00675         return text

Inserts an invisible element used as a link target.

Inserts an empty <span> element with an id attribute, used as an anchor
for link references.  We use <span></span> rather than <span/>
for browser portability.

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 551 of file text_html.py.

00551 
00552     def anchordef(self, id):
00553         """Inserts an invisible element used as a link target.
00554 
00555         Inserts an empty <span> element with an id attribute, used as an anchor
00556         for link references.  We use <span></span> rather than <span/>
00557         for browser portability.
00558         """
00559         # Don't add newlines, \n, as it will break pre and
00560         # line-numbered code sections (from line_achordef() method).
00561         #return '<a id="%s"></a>' % (id, ) # do not use - this breaks PRE sections for IE
00562         id = self.make_id_unique(id)
00563         id = self.qualify_id(id)
00564         return '<span class="anchor" id="%s"></span>' % id

Here is the call graph for this function:

def MoinMoin.formatter.text_html.Formatter.anchorlink (   self,
  on,
  name = '',
  kw 
)
Insert an <a> link pointing to an anchor on the same page.

Call once with on=1 to start the link, and a second time with
on=0 to end it.  No other arguments are needed on the second
call.

The name argument should be the same as the id provided to the
anchordef() method, or some other elment.  It should NOT start
with '#' as that will be added automatically.

The id argument, if provided, is instead the id of this link
itself and not of the target element the link references.

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 571 of file text_html.py.

00571 
00572     def anchorlink(self, on, name='', **kw):
00573         """Insert an <a> link pointing to an anchor on the same page.
00574 
00575         Call once with on=1 to start the link, and a second time with
00576         on=0 to end it.  No other arguments are needed on the second
00577         call.
00578 
00579         The name argument should be the same as the id provided to the
00580         anchordef() method, or some other elment.  It should NOT start
00581         with '#' as that will be added automatically.
00582 
00583         The id argument, if provided, is instead the id of this link
00584         itself and not of the target element the link references.
00585         """
00586         attrs = self._langAttr()
00587         if name:
00588             name = self.sanitize_to_id(name)
00589             attrs['href'] = '#' + self.qualify_id(name)
00590         if 'href' in kw:
00591             del kw['href']
00592         if on:
00593             str = self._open('a', attr=attrs, **kw)
00594         else:
00595             str = self._close('a')
00596         return str

Here is the call graph for this function:

def MoinMoin.formatter.text_html.Formatter.attachment_drawing (   self,
  url,
  text,
  kw 
)

Reimplemented from MoinMoin.formatter.FormatterBase.

Reimplemented in MoinMoin.formatter.text_gedit.Formatter.

Definition at line 657 of file text_html.py.

00657 
00658     def attachment_drawing(self, url, text, **kw):
00659         # ToDo try to move this to a better place e.g. __init__
00660         try:
00661             drawing_action = AttachFile.get_action(self.request, url, do='modify')
00662             assert drawing_action is not None
00663             attachment_drawing = wikiutil.importPlugin(self.request.cfg, 'action',
00664                                               drawing_action, 'attachment_drawing')
00665             return attachment_drawing(self, url, text, **kw)
00666         except (wikiutil.PluginMissingError, wikiutil.PluginAttributeError, AssertionError):
00667             return url

Reimplemented from MoinMoin.formatter.FormatterBase.

Reimplemented in MoinMoin.formatter.text_gedit.Formatter.

Definition at line 635 of file text_html.py.

00635 
00636     def attachment_image(self, url, **kw):
00637         _ = self.request.getText
00638         pagename, filename = AttachFile.absoluteName(url, self.page.page_name)
00639         fname = wikiutil.taintfilename(filename)
00640         exists = AttachFile.exists(self.request, pagename, fname)
00641         if exists:
00642             kw['css'] = 'attachment'
00643             kw['src'] = AttachFile.getAttachUrl(pagename, fname, self.request, addts=1)
00644             title = _('Inlined image: %(url)s') % {'url': self.text(url)}
00645             if not 'title' in kw:
00646                 kw['title'] = title
00647             # alt is required for images:
00648             if not 'alt' in kw:
00649                 kw['alt'] = kw['title']
00650             return self.image(**kw)
00651         else:
00652             title = _('Upload new attachment "%(filename)s"') % {'filename': fname}
00653             img = self.icon('attachimg')
00654             css = 'nonexistent'
00655             target = AttachFile.getAttachUrl(pagename, fname, self.request, do='upload_form')
00656             return self.url(1, target, css=css, title=title) + img + self.url(0)

Here is the call graph for this function:

def MoinMoin.formatter.FormatterBase.attachment_inlined (   self,
  url,
  text,
  kw 
) [inherited]

Reimplemented in MoinMoin.formatter.text_gedit.Formatter.

Definition at line 123 of file __init__.py.

00123 
00124     def attachment_inlined(self, url, text, **kw):
00125         from MoinMoin.action import AttachFile
00126         import os
00127         _ = self.request.getText
00128         pagename, filename = AttachFile.absoluteName(url, self.page.page_name)
00129         fname = wikiutil.taintfilename(filename)
00130         fpath = AttachFile.getFilename(self.request, pagename, fname)
00131         ext = os.path.splitext(filename)[1]
00132         Parser = wikiutil.getParserForExtension(self.request.cfg, ext)
00133         if Parser is not None:
00134             try:
00135                 content = file(fpath, 'r').read()
00136                 # Try to decode text. It might return junk, but we don't
00137                 # have enough information with attachments.
00138                 content = wikiutil.decodeUnknownInput(content)
00139                 colorizer = Parser(content, self.request, filename=filename)
00140                 colorizer.format(self)
00141             except IOError:
00142                 pass
00143 
00144         return (self.attachment_link(1, url) +
00145                 self.text(text) +
00146                 self.attachment_link(0))

Here is the call graph for this function:

def MoinMoin.formatter.FormatterBase.attachment_link (   self,
  on,
  url = None,
  kw 
) [inherited]

Reimplemented in MoinMoin.formatter.text_docbook.Formatter, MoinMoin.formatter.dom_xml.Formatter, MoinMoin.formatter.text_plain.Formatter, MoinMoin.formatter.text_gedit.Formatter, and MoinMoin.formatter.text_xml.Formatter.

Definition at line 116 of file __init__.py.

00116 
00117     def attachment_link(self, on, url=None, **kw):
        raise NotImplementedError

Here is the caller graph for this function:

def MoinMoin.formatter.text_html.Formatter.attachment_link (   self,
  on,
  url = None,
  querystr = None,
  kw 
)
Link to an attachment.

    @param on: 1/True=start link, 0/False=end link
    @param url: filename.ext or PageName/filename.ext

Definition at line 605 of file text_html.py.

00605 
00606     def attachment_link(self, on, url=None, querystr=None, **kw):
00607         """ Link to an attachment.
00608 
00609             @param on: 1/True=start link, 0/False=end link
00610             @param url: filename.ext or PageName/filename.ext
00611         """
00612         assert on in (0, 1, False, True) # make sure we get called the new way, not like the 1.5 api was
00613         _ = self.request.getText
00614         if querystr is None:
00615             querystr = {}
00616         assert isinstance(querystr, dict) # new in 1.6, only support dicts
00617         if 'do' not in querystr:
00618             querystr['do'] = 'view'
00619         if on:
00620             pagename, filename = AttachFile.absoluteName(url, self.page.page_name)
00621             #logging.debug("attachment_link: url %s pagename %s filename %s" % (url, pagename, filename))
00622             fname = wikiutil.taintfilename(filename)
00623             if AttachFile.exists(self.request, pagename, fname):
00624                 target = AttachFile.getAttachUrl(pagename, fname, self.request, do=querystr['do'])
00625                 if not 'title' in kw:
00626                     kw['title'] = "attachment:%s" % url
00627                 kw['css'] = 'attachment'
00628             else:
00629                 target = AttachFile.getAttachUrl(pagename, fname, self.request, do='upload_form')
00630                 kw['title'] = _('Upload new attachment "%(filename)s"') % {'filename': fname}
00631                 kw['css'] = 'attachment nonexistent'
00632             return self.url(on, target, **kw)
00633         else:
00634             return self.url(on)

Here is the call graph for this function:

def MoinMoin.formatter.text_html.Formatter.big (   self,
  on,
  kw 
)
Creates a <big> element for larger font.

Call once with on=1 to start the region, and a second time
with on=0 to end it.

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 783 of file text_html.py.

00783 
00784     def big(self, on, **kw):
00785         """Creates a <big> element for larger font.
00786 
00787         Call once with on=1 to start the region, and a second time
00788         with on=0 to end it.
00789         """
00790         tag = 'big'
00791         if on:
00792             return self._open(tag, allowed_attrs=[], **kw)
00793         return self._close(tag)
00794 

Here is the call graph for this function:

def MoinMoin.formatter.text_html.Formatter.bullet_list (   self,
  on,
  kw 
)
Creates an HTML ordered list, <ul> element.

The 'type' if specified can be any legal unnumbered
list-style-type, such as 'disc','square', etc.

Call once with on=1 to start the list, and a second time
with on=0 to end it.

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 1063 of file text_html.py.

01063 
01064     def bullet_list(self, on, **kw):
01065         """Creates an HTML ordered list, <ul> element.
01066 
01067         The 'type' if specified can be any legal unnumbered
01068         list-style-type, such as 'disc','square', etc.
01069 
01070         Call once with on=1 to start the list, and a second time
01071         with on=0 to end it.
01072         """
01073         tag = 'ul'
01074         if on:
01075             tagstr = self._open(tag, newline=1, **kw)
01076         else:
01077             tagstr = self._close(tag, newline=1)
01078         return tagstr

Here is the call graph for this function:

def MoinMoin.formatter.text_html.Formatter.code (   self,
  on,
  kw 
)
Creates a <tt> element for inline code or monospaced text.

Call once with on=1 to start the region, and a second time
with on=0 to end it.

Any text within this section will have spaces converted to
non-break spaces.

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 757 of file text_html.py.

00757 
00758     def code(self, on, **kw):
00759         """Creates a <tt> element for inline code or monospaced text.
00760 
00761         Call once with on=1 to start the region, and a second time
00762         with on=0 to end it.
00763 
00764         Any text within this section will have spaces converted to
00765         non-break spaces.
00766         """
00767         tag = 'tt'
00768         self._in_code = on
00769         if on:
00770             return self._open(tag, allowed_attrs=[], **kw)
00771         return self._close(tag)

Here is the call graph for this function:

def MoinMoin.formatter.FormatterBase.code_area (   self,
  on,
  code_id,
  kw 
) [inherited]

Definition at line 248 of file __init__.py.

00248 
00249     def code_area(self, on, code_id, **kw):
00250         raise NotImplementedError

def MoinMoin.formatter.text_html.Formatter.code_area (   self,
  on,
  code_id,
  code_type = 'code',
  show = 0,
  start = -1,
  step = -1,
  msg = None 
)
Creates a formatted code region, with line numbering.

This region is formatted as a <div> with a <pre> inside it.  The
code_id argument is assigned to the 'id' of the div element, and
must be unique within the document.  The show, start, and step are
used for line numbering.

Note this is not like most formatter methods, it can not take any
extra keyword arguments.

Call once with on=1 to start the region, and a second time
with on=0 to end it.

the msg string is not escaped

Definition at line 862 of file text_html.py.

00862 
00863     def code_area(self, on, code_id, code_type='code', show=0, start=-1, step=-1, msg=None):
00864         """Creates a formatted code region, with line numbering.
00865 
00866         This region is formatted as a <div> with a <pre> inside it.  The
00867         code_id argument is assigned to the 'id' of the div element, and
00868         must be unique within the document.  The show, start, and step are
00869         used for line numbering.
00870 
00871         Note this is not like most formatter methods, it can not take any
00872         extra keyword arguments.
00873 
00874         Call once with on=1 to start the region, and a second time
00875         with on=0 to end it.
00876 
00877         the msg string is not escaped
00878         """
00879         _ = self.request.getText
00880         res = []
00881         if on:
00882             code_id = self.sanitize_to_id('CA-%s' % code_id)
00883             ci = self.qualify_id(self.make_id_unique(code_id))
00884 
00885             # Open a code area
00886             self._in_code_area = 1
00887             self._in_code_line = 0
00888             # id in here no longer used
00889             self._code_area_state = [None, show, start, step, start]
00890 
00891             if msg:
00892                 attr = {'class': 'codemsg'}
00893                 res.append(self._open('div', attr={'class': 'codemsg'}))
00894                 res.append(msg)
00895                 res.append(self._close('div'))
00896 
00897             # Open the code div - using left to right always!
00898             attr = {'class': 'codearea', 'lang': 'en', 'dir': 'ltr'}
00899             res.append(self._open('div', attr=attr))
00900 
00901             # Add the script only in the first code area on the page
00902             if self._code_area_js == 0 and self._code_area_state[1] >= 0:
00903                 res.append(self._toggleLineNumbersScript)
00904                 self._code_area_js = 1
00905 
00906             # Add line number link, but only for JavaScript enabled browsers.
00907             if self._code_area_state[1] >= 0:
00908                 toggleLineNumbersLink = r'''
00909 <script type="text/javascript">
00910 document.write('<a href="#" onclick="return togglenumber(\'%s\', %d, %d);" \
00911                 class="codenumbers">%s<\/a>');
00912 </script>
00913 ''' % (ci, self._code_area_state[2], self._code_area_state[3],
00914        _("Toggle line numbers"))
00915                 res.append(toggleLineNumbersLink)
00916 
00917             # Open pre - using left to right always!
00918             attr = {'id': ci, 'lang': 'en', 'dir': 'ltr'}
00919             res.append(self._open('pre', newline=True, attr=attr, is_unique=True))
00920         else:
00921             # Close code area
00922             res = []
00923             if self._in_code_line:
00924                 res.append(self.code_line(0))
00925             res.append(self._close('pre'))
00926             res.append(self._close('div'))
00927 
00928             # Update state
00929             self._in_code_area = 0
00930 
00931         return ''.join(res)

Here is the call graph for this function:

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 932 of file text_html.py.

00932 
00933     def code_line(self, on):
00934         res = ''
00935         if not on or (on and self._in_code_line):
00936             res += '</span>\n'
00937         if on:
00938             res += '<span class="line">'
00939             if self._code_area_state[1] > 0:
00940                 res += '<span class="LineNumber">%4d </span>' % (self._code_area_state[4], )
00941                 self._code_area_state[4] += self._code_area_state[3]
00942         self._in_code_line = on != 0
00943         return res

def MoinMoin.formatter.text_html.Formatter.code_token (   self,
  on,
  tok_type 
)

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 944 of file text_html.py.

00944 
00945     def code_token(self, on, tok_type):
00946         return ['<span class="%s">' % tok_type, '</span>'][not on]

def MoinMoin.formatter.FormatterBase.comment (   self,
  text,
  kw 
) [inherited]

Reimplemented in MoinMoin.formatter.text_gedit.Formatter.

Definition at line 389 of file __init__.py.

00389 
00390     def comment(self, text, **kw):
00391         return ""

Gives the definition to a definition item, HTML element <dd>.

Call once with on=1 to start the definition, and a second time
with on=0 to end it.

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 1119 of file text_html.py.

01119 
01120     def definition_desc(self, on, **kw):
01121         """Gives the definition to a definition item, HTML element <dd>.
01122 
01123         Call once with on=1 to start the definition, and a second time
01124         with on=0 to end it.
01125         """
01126         tag = 'dd'
01127         if on:
01128             tagstr = self._open(tag, newline=1, **kw)
01129         else:
01130             tagstr = self._close(tag, newline=0)
01131         return tagstr

Here is the call graph for this function:

Creates an HTML definition list, <dl> element.

Call once with on=1 to start the list, and a second time
with on=0 to end it.

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 1093 of file text_html.py.

01093 
01094     def definition_list(self, on, **kw):
01095         """Creates an HTML definition list, <dl> element.
01096 
01097         Call once with on=1 to start the list, and a second time
01098         with on=0 to end it.
01099         """
01100         tag = 'dl'
01101         if on:
01102             tagstr = self._open(tag, newline=1, **kw)
01103         else:
01104             tagstr = self._close(tag, newline=1)
01105         return tagstr

Here is the call graph for this function:

def MoinMoin.formatter.FormatterBase.definition_term (   self,
  on,
  compact = 0,
  kw 
) [inherited]

Reimplemented in MoinMoin.formatter.dom_xml.Formatter, MoinMoin.formatter.text_docbook.Formatter, MoinMoin.formatter.text_plain.Formatter, and MoinMoin.formatter.text_xml.Formatter.

Definition at line 285 of file __init__.py.

00285 
00286     def definition_term(self, on, compact=0, **kw):
00287         raise NotImplementedError

Adds a new term to a definition list, HTML element <dt>.

Call once with on=1 to start the term, and a second time
with on=0 to end it.

Definition at line 1106 of file text_html.py.

01106 
01107     def definition_term(self, on, **kw):
01108         """Adds a new term to a definition list, HTML element <dt>.
01109 
01110         Call once with on=1 to start the term, and a second time
01111         with on=0 to end it.
01112         """
01113         tag = 'dt'
01114         if on:
01115             tagstr = self._open(tag, newline=1, **kw)
01116         else:
01117             tagstr = self._close(tag, newline=0)
01118         return tagstr

Here is the call graph for this function:

def MoinMoin.formatter.text_html.Formatter.div (   self,
  on,
  kw 
)
open/close a blocklevel division 

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 1314 of file text_html.py.

01314 
01315     def div(self, on, **kw):
01316         css_class = kw.get('css_class')
01317         # the display of comment class divs depends on a user setting:
01318         if css_class and 'comment' in css_class.split():
01319             style = kw.get('style')
01320             display = self.request.user.show_comments and "display:''" or "display:none"
01321             if not style:
01322                 style = display
01323             else:
01324                 style += "; %s" % display
01325             kw['style'] = style
01326         tag = 'div'
01327         if on:
01328             return self._open(tag, **kw)
01329         return self._close(tag)

Here is the call graph for this function:

def MoinMoin.formatter.text_html.Formatter.emphasis (   self,
  on,
  kw 
)
Creates an HTML <em> element.

Call once with on=1 to start the region, and a second time
with on=0 to end it.

Reimplemented from MoinMoin.formatter.FormatterBase.

Reimplemented in MoinMoin.formatter.text_gedit.Formatter.

Definition at line 689 of file text_html.py.

00689 
00690     def emphasis(self, on, **kw):
00691         """Creates an HTML <em> element.
00692 
00693         Call once with on=1 to start the region, and a second time
00694         with on=0 to end it.
00695         """
00696         tag = 'em'
00697         if on:
00698             return self._open(tag, allowed_attrs=[], **kw)
00699         return self._close(tag)

Here is the call graph for this function:

def MoinMoin.formatter.FormatterBase.endContent (   self) [inherited]

Reimplemented in MoinMoin.formatter.text_docbook.Formatter, and MoinMoin.macro.TableOfContents.TOCFormatter.

Definition at line 80 of file __init__.py.

00080 
00081     def endContent(self):
00082         if self.page:
00083             self.request.uid_generator.end()
00084         return ""

def MoinMoin.formatter.text_html.Formatter.endContent (   self,
  newline = True 
)
Close page content div.

A link anchor is provided at the end of the div, with
an id of 'bottom' (modified by the request ID cache).

Definition at line 426 of file text_html.py.

00426 
00427     def endContent(self, newline=True):
00428         """ Close page content div.
00429 
00430         A link anchor is provided at the end of the div, with
00431         an id of 'bottom' (modified by the request ID cache).
00432         """
00433 
00434         result = []
00435         result.append(self.anchordef('bottom'))
00436         result.append(self._close('div', newline=newline))
00437         if hasattr(self, 'page'):
00438             self.request.uid_generator.end()
00439         return ''.join(result)

Here is the call graph for this function:

Reimplemented in MoinMoin.formatter.dom_xml.Formatter, MoinMoin.formatter.text_docbook.Formatter, MoinMoin.formatter.text_xml.Formatter, and MoinMoin.formatter.text_plain.Formatter.

Definition at line 72 of file __init__.py.

00072 
00073     def endDocument(self):
00074         return ""

Here is the caller graph for this function:

def MoinMoin.formatter.text_html.Formatter.escapedText (   self,
  on,
  kw 
)
This allows emitting text as-is, anything special will
    be escaped (at least in HTML, some text output format
    would possibly do nothing here)

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 1299 of file text_html.py.

01299 
01300     def escapedText(self, text, **kw):
01301         txt = wikiutil.escape(text)
01302         if kw:
01303             return self._open('span', **kw) + txt + self._close('span')
01304         return txt

Here is the call graph for this function:

def MoinMoin.formatter.text_html.Formatter.heading (   self,
  on,
  depth,
  kw 
)

Reimplemented from MoinMoin.formatter.FormatterBase.

Reimplemented in MoinMoin.formatter.text_gedit.Formatter.

Definition at line 1132 of file text_html.py.

01132 
01133     def heading(self, on, depth, **kw):
01134         # remember depth of first heading, and adapt counting depth accordingly
01135         if not self._base_depth:
01136             self._base_depth = depth
01137 
01138         count_depth = max(depth - (self._base_depth - 1), 1)
01139 
01140         # check numbering, possibly changing the default
01141         if self._show_section_numbers is None:
01142             self._show_section_numbers = self.cfg.show_section_numbers
01143             numbering = self.request.getPragma('section-numbers', '').lower()
01144             if numbering in ['0', 'off']:
01145                 self._show_section_numbers = 0
01146             elif numbering in ['1', 'on']:
01147                 self._show_section_numbers = 1
01148             elif numbering in ['2', '3', '4', '5', '6']:
01149                 # explicit base level for section number display
01150                 self._show_section_numbers = int(numbering)
01151 
01152         heading_depth = depth
01153 
01154         # closing tag, with empty line after, to make source more readable
01155         if not on:
01156             return self._close('h%d' % heading_depth) + '\n'
01157 
01158         # create section number
01159         number = ''
01160         if self._show_section_numbers:
01161             # count headings on all levels
01162             self.request._fmt_hd_counters = self.request._fmt_hd_counters[:count_depth]
01163             while len(self.request._fmt_hd_counters) < count_depth:
01164                 self.request._fmt_hd_counters.append(0)
01165             self.request._fmt_hd_counters[-1] = self.request._fmt_hd_counters[-1] + 1
01166             number = '.'.join([str(x) for x in self.request._fmt_hd_counters[self._show_section_numbers-1:]])
01167             if number: number += ". "
01168 
01169         # Add space before heading, easier to check source code
01170         result = '\n' + self._open('h%d' % heading_depth, **kw)
01171 
01172         if self.request.user.show_topbottom:
01173             result += "%s%s%s%s%s%s" % (
01174                        self.anchorlink(1, "bottom"), self.icon('bottom'), self.anchorlink(0),
01175                        self.anchorlink(1, "top"), self.icon('top'), self.anchorlink(0))
01176 
01177         return "%s%s" % (result, number)
01178 

def MoinMoin.formatter.text_html.Formatter.highlight (   self,
  on,
  kw 
)
Creates a text span for highlighting (css class "highlight").

Call once with on=1 to start the region, and a second time
with on=0 to end it.

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 711 of file text_html.py.

00711 
00712     def highlight(self, on, **kw):
00713         """Creates a text span for highlighting (css class "highlight").
00714 
00715         Call once with on=1 to start the region, and a second time
00716         with on=0 to end it.
00717         """
00718         tag = 'strong'
00719         if on:
00720             return self._open(tag, attr={'class': 'highlight'}, allowed_attrs=[], **kw)
00721         return self._close(tag)

Here is the call graph for this function:

def MoinMoin.formatter.text_html.Formatter.icon (   self,
  type 
)

Reimplemented from MoinMoin.formatter.FormatterBase.

Reimplemented in MoinMoin.formatter.text_gedit.Formatter.

Definition at line 1005 of file text_html.py.

01005 
01006     def icon(self, type):
01007         return self.request.theme.make_icon(type)

def MoinMoin.formatter.text_html.Formatter.image (   self,
  src = None,
  kw 
)
Creates an inline image with an <img> element.

The src argument must be the URL to the image file.

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 1010 of file text_html.py.

01010 
01011     def image(self, src=None, **kw):
01012         """Creates an inline image with an <img> element.
01013 
01014         The src argument must be the URL to the image file.
01015         """
01016         if src:
01017             kw['src'] = src
01018         return self._open('img', **kw)

Here is the call graph for this function:

def MoinMoin.formatter.text_html.Formatter.interwikilink (   self,
  on,
  interwiki = '',
  pagename = '',
  kw 
)
@keyword title: override using the interwiki wikiname as title

Reimplemented from MoinMoin.formatter.FormatterBase.

Reimplemented in MoinMoin.formatter.text_gedit.Formatter.

Definition at line 483 of file text_html.py.

00483 
00484     def interwikilink(self, on, interwiki='', pagename='', **kw):
00485         """
00486         @keyword title: override using the interwiki wikiname as title
00487         """
00488         querystr = kw.get('querystr', {})
00489         wikitag, wikiurl, wikitail, wikitag_bad = wikiutil.resolve_interwiki(self.request, interwiki, pagename)
00490         wikiurl = wikiutil.mapURL(self.request, wikiurl)
00491         if wikitag == 'Self': # for own wiki, do simple links
00492             wikitail = wikiutil.url_unquote(wikitail)
00493             try: # XXX this is the only place where we access self.page - do we need it? Crashes silently on actions!
00494                 pagename = wikiutil.AbsPageName(self.page.page_name, wikitail)
00495             except:
00496                 pagename = wikitail
00497             return self.pagelink(on, pagename, **kw)
00498         else: # return InterWiki hyperlink
00499             if on:
00500                 href = wikiutil.join_wiki(wikiurl, wikitail)
00501                 if querystr:
00502                     separator = ('?', '&')['?' in href]
00503                     href = '%s%s%s' % (href, separator, wikiutil.makeQueryString(querystr))
00504                 anchor = kw.get('anchor')
00505                 if anchor:
00506                     href = '%s#%s' % (href, self.sanitize_to_id(anchor))
00507                 if wikitag_bad:
00508                     html_class = 'badinterwiki'
00509                 else:
00510                     html_class = 'interwiki'
00511                 title = kw.get('title', wikitag)
00512                 return self.url(1, href, title=title, css=html_class) # interwiki links with umlauts
00513             else:
00514                 return self.url(0)

Here is the call graph for this function:

def MoinMoin.formatter.text_html.Formatter.lang (   self,
  on,
  lang_name 
)
Insert text with specific lang and direction.

    Enclose within span tag if lang_name is different from
    the current lang

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 440 of file text_html.py.

00440 
00441     def lang(self, on, lang_name):
00442         """ Insert text with specific lang and direction.
00443 
00444             Enclose within span tag if lang_name is different from
00445             the current lang
00446         """
00447         tag = 'span'
00448         if lang_name != self.request.current_lang:
00449             # Enclose text in span using lang attributes
00450             if on:
00451                 attr = self._langAttr(lang=lang_name)
00452                 return self._open(tag, attr=attr)
00453             return self._close(tag)
00454 
00455         # Direction did not change, no need for span
00456         return ''

Here is the call graph for this function:

Reimplemented from MoinMoin.formatter.FormatterBase.

Reimplemented in MoinMoin.formatter.text_gedit.Formatter.

Definition at line 565 of file text_html.py.

00565 
00566     def line_anchordef(self, lineno):
00567         if line_anchors:
00568             return self.anchordef("line-%d" % lineno)
00569         else:
00570             return ''

Here is the call graph for this function:

def MoinMoin.formatter.text_html.Formatter.line_anchorlink (   self,
  on,
  lineno = 0 
)

Reimplemented from MoinMoin.formatter.FormatterBase.

Reimplemented in MoinMoin.formatter.text_gedit.Formatter.

Definition at line 597 of file text_html.py.

00597 
00598     def line_anchorlink(self, on, lineno=0):
00599         if line_anchors:
00600             return self.anchorlink(on, name="line-%d" % lineno)
00601         else:
00602             return ''

Here is the call graph for this function:

def MoinMoin.formatter.text_html.Formatter.linebreak (   self,
  preformatted = 1 
)
Creates a line break in the HTML output.

If preformatted is true a <br> element is inserted, otherwise
the linebreak will only be visible in the HTML source.

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 965 of file text_html.py.

00965 
00966     def linebreak(self, preformatted=1):
00967         """Creates a line break in the HTML output.
00968 
00969         If preformatted is true a <br> element is inserted, otherwise
00970         the linebreak will only be visible in the HTML source.
00971         """
00972         if self._in_code_area:
00973             preformatted = 1
00974         return ['\n', '<br>\n'][not preformatted] + self._indent_spaces()

Here is the call graph for this function:

def MoinMoin.formatter.text_html.Formatter.listitem (   self,
  on,
  kw 
)
Adds a list item, <li> element, to a previously opened
bullet or number list.

Call once with on=1 to start the region, and a second time
with on=0 to end it.

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 1079 of file text_html.py.

01079 
01080     def listitem(self, on, **kw):
01081         """Adds a list item, <li> element, to a previously opened
01082         bullet or number list.
01083 
01084         Call once with on=1 to start the region, and a second time
01085         with on=0 to end it.
01086         """
01087         tag = 'li'
01088         if on:
01089             tagstr = self._open(tag, newline=1, **kw)
01090         else:
01091             tagstr = self._close(tag, newline=1)
01092         return tagstr

Here is the call graph for this function:

def MoinMoin.formatter.FormatterBase.macro (   self,
  macro_obj,
  name,
  args,
  markup = None 
) [inherited]

Reimplemented in MoinMoin.formatter.text_docbook.Formatter, MoinMoin.formatter.dom_xml.Formatter, MoinMoin.formatter.text_gedit.Formatter, and MoinMoin.macro.TableOfContents.TOCFormatter.

Definition at line 307 of file __init__.py.

00307 
00308     def macro(self, macro_obj, name, args, markup=None):
00309         # call the macro
00310         try:
00311             return macro_obj.execute(name, args)
00312         except ImportError, err:
00313             errmsg = unicode(err)
00314             if not name in errmsg:
00315                 raise
00316             if markup:
00317                 return (self.span(1, title=errmsg) +
00318                         self.text(markup) +
00319                         self.span(0))
00320             else:
                return self.text(errmsg)

Here is the call graph for this function:

def MoinMoin.formatter.FormatterBase.make_id_unique (   self,
  id 
) [inherited]
Take an ID and make it unique in the current namespace.

Definition at line 406 of file __init__.py.

00406 
00407     def make_id_unique(self, id):
00408         '''
00409         Take an ID and make it unique in the current namespace.
00410         '''
00411         ns = self.request.uid_generator.include_id
00412         if not ns is None:
00413             ns = self.sanitize_to_id(ns)
00414         id = self.sanitize_to_id(id)
00415         id = self.request.uid_generator(id, ns)
00416         return id

Here is the call graph for this function:

Here is the caller graph for this function:

def MoinMoin.formatter.FormatterBase.nowikiword (   self,
  text 
) [inherited]

Reimplemented in MoinMoin.formatter.text_gedit.Formatter.

Definition at line 184 of file __init__.py.

00184 
00185     def nowikiword(self, text):
00186         return self.text(text)

Here is the call graph for this function:

def MoinMoin.formatter.text_html.Formatter.number_list (   self,
  on,
  type = None,
  start = None,
  kw 
)
Creates an HTML ordered list, <ol> element.

The 'type' if specified can be any legal numbered
list-style-type, such as 'decimal','lower-roman', etc.

The 'start' argument if specified gives the numeric value of
the first list item (default is 1).

Call once with on=1 to start the list, and a second time
with on=0 to end it.

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 1039 of file text_html.py.

01039 
01040     def number_list(self, on, type=None, start=None, **kw):
01041         """Creates an HTML ordered list, <ol> element.
01042 
01043         The 'type' if specified can be any legal numbered
01044         list-style-type, such as 'decimal','lower-roman', etc.
01045 
01046         The 'start' argument if specified gives the numeric value of
01047         the first list item (default is 1).
01048 
01049         Call once with on=1 to start the list, and a second time
01050         with on=0 to end it.
01051         """
01052         tag = 'ol'
01053         if on:
01054             attr = {}
01055             if type is not None:
01056                 attr['type'] = type
01057             if start is not None:
01058                 attr['start'] = start
01059             tagstr = self._open(tag, newline=1, attr=attr, **kw)
01060         else:
01061             tagstr = self._close(tag, newline=1)
01062         return tagstr

Here is the call graph for this function:

def MoinMoin.formatter.text_html.Formatter.pagelink (   self,
  on,
  pagename = '',
  page = None,
  kw 
)
Link to a page.

    formatter.text_python will use an optimized call with a page!=None
    parameter. DO NOT USE THIS YOURSELF OR IT WILL BREAK.

    See wikiutil.link_tag() for possible keyword parameters.

Reimplemented from MoinMoin.formatter.FormatterBase.

Reimplemented in MoinMoin.formatter.text_gedit.Formatter.

Definition at line 459 of file text_html.py.

00459 
00460     def pagelink(self, on, pagename='', page=None, **kw):
00461         """ Link to a page.
00462 
00463             formatter.text_python will use an optimized call with a page!=None
00464             parameter. DO NOT USE THIS YOURSELF OR IT WILL BREAK.
00465 
00466             See wikiutil.link_tag() for possible keyword parameters.
00467         """
00468         FormatterBase.pagelink(self, on, pagename, page, **kw)
00469         if 'generated' in kw:
00470             del kw['generated']
00471         if page is None:
00472             page = Page(self.request, pagename, formatter=self)
00473         if self.request.user.show_nonexist_qm and on and not page.exists():
00474             self.pagelink_preclosed = True
00475             return (page.link_to(self.request, on=1, **kw) +
00476                     self.text("?") +
00477                     page.link_to(self.request, on=0, **kw))
00478         elif not on and self.pagelink_preclosed:
00479             self.pagelink_preclosed = False
00480             return ""
00481         else:
00482             return page.link_to(self.request, on=on, **kw)

Here is the call graph for this function:

def MoinMoin.formatter.text_html.Formatter.paragraph (   self,
  on,
  kw 
)
Creates a paragraph with a <p> element.

Call once with on=1 to start the region, and a second time
with on=0 to end it.

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 975 of file text_html.py.

00975 
00976     def paragraph(self, on, **kw):
00977         """Creates a paragraph with a <p> element.
00978 
00979         Call once with on=1 to start the region, and a second time
00980         with on=0 to end it.
00981         """
00982         if self._terse:
00983             return ''
00984         FormatterBase.paragraph(self, on)
00985         tag = 'p'
00986         if on:
00987             tagstr = self._open(tag, **kw)
00988         else:
00989             tagstr = self._close(tag)
00990         return tagstr

Here is the call graph for this function:

def MoinMoin.formatter.FormatterBase.parser (   self,
  parser_name,
  lines 
) [inherited]
parser_name MUST be valid!
    writes out the result instead of returning it!

Reimplemented in MoinMoin.formatter.dom_xml.Formatter, and MoinMoin.formatter.text_gedit.Formatter.

Definition at line 331 of file __init__.py.

00331 
00332     def parser(self, parser_name, lines):
00333         """ parser_name MUST be valid!
00334             writes out the result instead of returning it!
00335         """
00336         # attention: this is copied into text_python!
00337         parser = wikiutil.searchAndImportPlugin(self.request.cfg, "parser", parser_name)
00338         args = None
00339         if lines:
00340             args = self._get_bang_args(lines[0])
00341             logging.debug("formatter.parser: parser args %r" % args)
00342             if args is not None:
00343                 lines = lines[1:]
00344         if lines and not lines[0]:
00345             lines = lines[1:]
00346         if lines and not lines[-1].strip():
00347             lines = lines[:-1]
00348         p = parser('\n'.join(lines), self.request, format_args=args)
00349         p.format(self)
00350         del p
00351         return ''

Here is the call graph for this function:

Here is the caller graph for this function:

def MoinMoin.formatter.text_html.Formatter.preformatted (   self,
  on,
  kw 
)
Creates a preformatted text region, with a <pre> element.

Call once with on=1 to start the region, and a second time
with on=0 to end it.

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 797 of file text_html.py.

00797 
00798     def preformatted(self, on, **kw):
00799         """Creates a preformatted text region, with a <pre> element.
00800 
00801         Call once with on=1 to start the region, and a second time
00802         with on=0 to end it.
00803         """
00804         FormatterBase.preformatted(self, on)
00805         tag = 'pre'
00806         if on:
00807             return self._open(tag, newline=1, **kw)
00808         return self._close(tag)

Here is the call graph for this function:

def MoinMoin.formatter.FormatterBase.qualify_id (   self,
  id 
) [inherited]
Take an ID and return a string that is qualified by
the current namespace; this default implementation
is suitable if the dot ('.') is valid in IDs for your
formatter.

Definition at line 417 of file __init__.py.

00417 
00418     def qualify_id(self, id):
00419         '''
00420         Take an ID and return a string that is qualified by
00421         the current namespace; this default implementation
00422         is suitable if the dot ('.') is valid in IDs for your
00423         formatter.
00424         '''
00425         ns = self.request.uid_generator.include_id
00426         if not ns is None:
00427             ns = self.sanitize_to_id(ns)
00428             return '%s.%s' % (ns, id)
00429         return id

Here is the call graph for this function:

Here is the caller graph for this function:

def MoinMoin.formatter.text_html.Formatter.rawHTML (   self,
  markup 
)
This allows emitting pre-formatted HTML markup, and should be
    used wisely (i.e. very seldom).

    Using this event while generating content results in unwanted
    effects, like loss of markup or insertion of CDATA sections
    when output goes to XML formats.

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 1305 of file text_html.py.

01305 
01306     def rawHTML(self, markup):
01307         return markup

def MoinMoin.formatter.text_html.Formatter.rule (   self,
  size = None,
  kw 
)
Creates a horizontal rule with an <hr> element.

If size is a number in the range [1..6], the CSS class of the rule
is set to 'hr1' through 'hr6'.  The intent is that the larger the
size number the thicker or bolder the rule will be.

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 991 of file text_html.py.

00991 
00992     def rule(self, size=None, **kw):
00993         """Creates a horizontal rule with an <hr> element.
00994 
00995         If size is a number in the range [1..6], the CSS class of the rule
00996         is set to 'hr1' through 'hr6'.  The intent is that the larger the
00997         size number the thicker or bolder the rule will be.
00998         """
00999         if size and 1 <= size <= 6:
01000             # Add hr class: hr1 - hr6
01001             return self._open('hr', newline=1, attr={'class': 'hr%d' % size}, **kw)
01002         return self._open('hr', newline=1, **kw)

Here is the call graph for this function:

Take 'text' and return something that is a valid ID
for this formatter.
The default returns the first non-space character of the string.

Because of the way this is used, it must be idempotent,
i.e. calling it on an already sanitized id must yield the
original id.

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 1346 of file text_html.py.

01346 
01347     def sanitize_to_id(self, text):
01348         return wikiutil.anchor_name_from_text(text)
01349 
def MoinMoin.formatter.FormatterBase.set_highlight_re (   self,
  hi_re = None 
) [inherited]
set the highlighting regular expression (e.g. for search terms)

@param hi_re: either a valid re as str/unicode (you may want to use
      re.escape before passing generic strings!) or a compiled
      re object. raises re.error for invalid re.

Definition at line 43 of file __init__.py.

00043 
00044     def set_highlight_re(self, hi_re=None):
00045         """ set the highlighting regular expression (e.g. for search terms)
00046 
00047         @param hi_re: either a valid re as str/unicode (you may want to use
00048                       re.escape before passing generic strings!) or a compiled
00049                       re object. raises re.error for invalid re.
00050         """
00051         if isinstance(hi_re, (str, unicode)):
00052             hi_re = re.compile(hi_re, re.U + re.IGNORECASE)
00053         self._highlight_re = hi_re

def MoinMoin.formatter.FormatterBase.setPage (   self,
  page 
) [inherited]

Reimplemented in MoinMoin.formatter.dom_xml.Formatter.

Definition at line 57 of file __init__.py.

00057 
00058     def setPage(self, page):
00059         self.page = page

def MoinMoin.formatter.text_html.Formatter.small (   self,
  on,
  kw 
)
Creates a <small> element for smaller font.

Call once with on=1 to start the region, and a second time
with on=0 to end it.

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 772 of file text_html.py.

00772 
00773     def small(self, on, **kw):
00774         """Creates a <small> element for smaller font.
00775 
00776         Call once with on=1 to start the region, and a second time
00777         with on=0 to end it.
00778         """
00779         tag = 'small'
00780         if on:
00781             return self._open(tag, allowed_attrs=[], **kw)
00782         return self._close(tag)

Here is the call graph for this function:

def MoinMoin.formatter.FormatterBase.smiley (   self,
  text 
) [inherited]

Reimplemented in MoinMoin.formatter.text_docbook.Formatter, MoinMoin.formatter.dom_xml.Formatter, and MoinMoin.formatter.text_plain.Formatter.

Definition at line 181 of file __init__.py.

00181 
00182     def smiley(self, text):
00183         return text

def MoinMoin.formatter.text_html.Formatter.span (   self,
  on,
  kw 
)
open/close a inline span 

Reimplemented from MoinMoin.formatter.FormatterBase.

Reimplemented in MoinMoin.formatter.text_gedit.Formatter.

Definition at line 1330 of file text_html.py.

01330 
01331     def span(self, on, **kw):
01332         css_class = kw.get('css_class')
01333         # the display of comment class spans depends on a user setting:
01334         if css_class and 'comment' in css_class.split():
01335             style = kw.get('style')
01336             display = self.request.user.show_comments and "display:''" or "display:none"
01337             if not style:
01338                 style = display
01339             else:
01340                 style += "; %s" % display
01341             kw['style'] = style
01342         tag = 'span'
01343         if on:
01344             return self._open(tag, **kw)
01345         return self._close(tag)

Here is the call graph for this function:

def MoinMoin.formatter.FormatterBase.startContent (   self,
  content_id = "content",
  kw 
) [inherited]

Reimplemented in MoinMoin.formatter.text_docbook.Formatter, and MoinMoin.macro.TableOfContents.TOCFormatter.

Definition at line 75 of file __init__.py.

00075 
00076     def startContent(self, content_id="content", **kw):
00077         if self.page:
00078             self.request.uid_generator.begin(self.page.page_name)
00079         return ""

def MoinMoin.formatter.text_html.Formatter.startContent (   self,
  content_id = 'content',
  newline = True,
  kw 
)
Start page content div.

A link anchor is provided at the beginning of the div, with
an id of 'top' (modified by the request ID cache).

Definition at line 405 of file text_html.py.

00405 
00406     def startContent(self, content_id='content', newline=True, **kw):
00407         """ Start page content div.
00408 
00409         A link anchor is provided at the beginning of the div, with
00410         an id of 'top' (modified by the request ID cache).
00411         """
00412 
00413         if hasattr(self, 'page'):
00414             self.request.uid_generator.begin(self.page.page_name)
00415 
00416         result = []
00417         # Use the content language
00418         attr = self._langAttr(self.request.content_lang)
00419         attr['id'] = content_id
00420         result.append(self._open('div', newline=False, attr=attr,
00421                                  allowed_attrs=['align'], **kw))
00422         result.append(self.anchordef('top'))
00423         if newline:
00424             result.append('\n')
00425         return ''.join(result)

Here is the call graph for this function:

def MoinMoin.formatter.FormatterBase.startDocument (   self,
  pagename 
) [inherited]

Reimplemented in MoinMoin.formatter.dom_xml.Formatter, MoinMoin.formatter.text_docbook.Formatter, MoinMoin.formatter.text_xml.Formatter, and MoinMoin.formatter.text_plain.Formatter.

Definition at line 69 of file __init__.py.

00069 
00070     def startDocument(self, pagename):
00071         return ""

Here is the caller graph for this function:

def MoinMoin.formatter.text_html.Formatter.strike (   self,
  on,
  kw 
)
Creates a text span for line-through (strikeout) text (css class 'strike').

Call once with on=1 to start the region, and a second time
with on=0 to end it.

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 744 of file text_html.py.

00744 
00745     def strike(self, on, **kw):
00746         """Creates a text span for line-through (strikeout) text (css class 'strike').
00747 
00748         Call once with on=1 to start the region, and a second time
00749         with on=0 to end it.
00750         """
00751         # This does not use <strike> because has been deprecated in standard HTML.
00752         tag = 'span'
00753         if on:
00754             return self._open(tag, attr={'class': 'strike'},
00755                               allowed_attrs=[], **kw)
00756         return self._close(tag)

Here is the call graph for this function:

def MoinMoin.formatter.text_html.Formatter.strong (   self,
  on,
  kw 
)
Creates an HTML <strong> element.

Call once with on=1 to start the region, and a second time
with on=0 to end it.

Reimplemented from MoinMoin.formatter.FormatterBase.

Reimplemented in MoinMoin.formatter.text_gedit.Formatter.

Definition at line 678 of file text_html.py.

00678 
00679     def strong(self, on, **kw):
00680         """Creates an HTML <strong> element.
00681 
00682         Call once with on=1 to start the region, and a second time
00683         with on=0 to end it.
00684         """
00685         tag = 'strong'
00686         if on:
00687             return self._open(tag, allowed_attrs=[], **kw)
00688         return self._close(tag)

Here is the call graph for this function:

def MoinMoin.formatter.text_html.Formatter.sub (   self,
  on,
  kw 
)
Creates a <sub> element for subscript text.

Call once with on=1 to start the region, and a second time
with on=0 to end it.

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 733 of file text_html.py.

00733 
00734     def sub(self, on, **kw):
00735         """Creates a <sub> element for subscript text.
00736 
00737         Call once with on=1 to start the region, and a second time
00738         with on=0 to end it.
00739         """
00740         tag = 'sub'
00741         if on:
00742             return self._open(tag, allowed_attrs=[], **kw)
00743         return self._close(tag)

Here is the call graph for this function:

def MoinMoin.formatter.text_html.Formatter.sup (   self,
  on,
  kw 
)
Creates a <sup> element for superscript text.

Call once with on=1 to start the region, and a second time
with on=0 to end it.

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 722 of file text_html.py.

00722 
00723     def sup(self, on, **kw):
00724         """Creates a <sup> element for superscript text.
00725 
00726         Call once with on=1 to start the region, and a second time
00727         with on=0 to end it.
00728         """
00729         tag = 'sup'
00730         if on:
00731             return self._open(tag, allowed_attrs=[], **kw)
00732         return self._close(tag)

Here is the call graph for this function:

def MoinMoin.formatter.text_html.Formatter.sysmsg (   self,
  on,
  kw 
)
Emit a system message (embed it into the page).

    Normally used to indicate disabled options, or invalid markup.

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 1308 of file text_html.py.

01308 
01309     def sysmsg(self, on, **kw):
01310         tag = 'div'
01311         if on:
01312             return self._open(tag, attr={'class': 'message'}, **kw)
01313         return self._close(tag)

Here is the call graph for this function:

def MoinMoin.formatter.text_html.Formatter.table (   self,
  on,
  attrs = None,
  kw 
)
Create table

@param on: start table
@param attrs: table attributes
@rtype: string
@return start or end tag of a table

Reimplemented from MoinMoin.formatter.FormatterBase.

Reimplemented in MoinMoin.formatter.text_gedit.Formatter.

Definition at line 1238 of file text_html.py.

01238 
01239     def table(self, on, attrs=None, **kw):
01240         """ Create table
01241 
01242         @param on: start table
01243         @param attrs: table attributes
01244         @rtype: string
01245         @return start or end tag of a table
01246         """
01247         result = []
01248         if on:
01249             # Open div to get correct alignment with table width smaller
01250             # than 100%
01251             result.append(self._open('div', newline=1))
01252 
01253             # Open table
01254             if not attrs:
01255                 attrs = {}
01256             else:
01257                 attrs = self._checkTableAttr(attrs, 'table')
01258             result.append(self._open('table', newline=1, attr=attrs,
01259                                      allowed_attrs=self._allowed_table_attrs['table'],
01260                                      **kw))
01261             result.append(self._open('tbody', newline=1))
01262         else:
01263             # Close tbody, table, and then div
01264             result.append(self._close('tbody'))
01265             result.append(self._close('table'))
01266             result.append(self._close('div'))
01267 
01268         return ''.join(result)

Here is the call graph for this function:

def MoinMoin.formatter.text_html.Formatter.table_cell (   self,
  on,
  attrs = None,
  kw 
)

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 1281 of file text_html.py.

01281 
01282     def table_cell(self, on, attrs=None, **kw):
01283         tag = 'td'
01284         if on:
01285             if not attrs:
01286                 attrs = {}
01287             else:
01288                 attrs = self._checkTableAttr(attrs, '')
01289             return '  ' + self._open(tag, attr=attrs,
01290                              allowed_attrs=self._allowed_table_attrs[''],
01291                              **kw)
01292         return self._close(tag) + '\n'

Here is the call graph for this function:

def MoinMoin.formatter.text_html.Formatter.table_row (   self,
  on,
  attrs = None,
  kw 
)

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 1269 of file text_html.py.

01269 
01270     def table_row(self, on, attrs=None, **kw):
01271         tag = 'tr'
01272         if on:
01273             if not attrs:
01274                 attrs = {}
01275             else:
01276                 attrs = self._checkTableAttr(attrs, 'row')
01277             return self._open(tag, newline=1, attr=attrs,
01278                              allowed_attrs=self._allowed_table_attrs['row'],
01279                              **kw)
01280         return self._close(tag) + '\n'

Here is the call graph for this function:

def MoinMoin.formatter.text_html.Formatter.text (   self,
  text,
  kw 
)

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 1293 of file text_html.py.

01293 
01294     def text(self, text, **kw):
01295         txt = FormatterBase.text(self, text, **kw)
01296         if kw:
01297             return self._open('span', **kw) + txt + self._close('span')
01298         return txt

Here is the call graph for this function:

def MoinMoin.formatter.text_html.Formatter.transclusion (   self,
  on,
  kw 
)
Transcludes (includes/embeds) another object.

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 1019 of file text_html.py.

01019 
01020     def transclusion(self, on, **kw):
01021         """Transcludes (includes/embeds) another object."""
01022         if on:
01023             return self._open('object',
01024                               allowed_attrs=['archive', 'classid', 'codebase',
01025                                              'codetype', 'data', 'declare',
01026                                              'height', 'name', 'standby',
01027                                              'type', 'width', ],
01028                               **kw)
01029         else:
01030             return self._close('object')

Here is the call graph for this function:

Give a parameter to a transcluded object.

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 1031 of file text_html.py.

01031 
01032     def transclusion_param(self, **kw):
01033         """Give a parameter to a transcluded object."""
01034         return self._open('param',
01035                           allowed_attrs=['name', 'type', 'value', 'valuetype', ],
01036                           **kw)

Here is the call graph for this function:

def MoinMoin.formatter.text_html.Formatter.underline (   self,
  on,
  kw 
)
Creates a text span for underlining (css class "u").

Call once with on=1 to start the region, and a second time
with on=0 to end it.

Reimplemented from MoinMoin.formatter.FormatterBase.

Reimplemented in MoinMoin.formatter.text_gedit.Formatter.

Definition at line 700 of file text_html.py.

00700 
00701     def underline(self, on, **kw):
00702         """Creates a text span for underlining (css class "u").
00703 
00704         Call once with on=1 to start the region, and a second time
00705         with on=0 to end it.
00706         """
00707         tag = 'span'
00708         if on:
00709             return self._open(tag, attr={'class': 'u'}, allowed_attrs=[], **kw)
00710         return self._close(tag)

Here is the call graph for this function:

def MoinMoin.formatter.FormatterBase.url (   self,
  on,
  url = None,
  css = None,
  kw 
) [inherited]

Reimplemented in MoinMoin.formatter.text_docbook.Formatter, MoinMoin.formatter.dom_xml.Formatter, MoinMoin.formatter.text_xml.Formatter, and MoinMoin.formatter.text_plain.Formatter.

Definition at line 111 of file __init__.py.

00111 
00112     def url(self, on, url=None, css=None, **kw):
00113         raise NotImplementedError

Here is the caller graph for this function:

def MoinMoin.formatter.text_html.Formatter.url (   self,
  on,
  url = None,
  css = None,
  do_escape = None,
  kw 
)
Inserts an <a> element (you can give any A tag attributes as kw args).

@param on: 1 to start the link, 0 to end the link (no other arguments are needed when on==0).
@param url: the URL to link to; will go through Wiki URL mapping.
@param css: a space-separated list of CSS classes
@param do_escape: DEPRECATED and not used any more, please remove it from your code!
          We will remove this parameter in moin 1.8 (it used to filter url
          param through wikiutil.escape, but text_html formatter's _open
          will do it again, so this just leads to double escaping now).

Definition at line 515 of file text_html.py.

00515 
00516     def url(self, on, url=None, css=None, do_escape=None, **kw):
00517         """
00518         Inserts an <a> element (you can give any A tag attributes as kw args).
00519 
00520         @param on: 1 to start the link, 0 to end the link (no other arguments are needed when on==0).
00521         @param url: the URL to link to; will go through Wiki URL mapping.
00522         @param css: a space-separated list of CSS classes
00523         @param do_escape: DEPRECATED and not used any more, please remove it from your code!
00524                           We will remove this parameter in moin 1.8 (it used to filter url
00525                           param through wikiutil.escape, but text_html formatter's _open
00526                           will do it again, so this just leads to double escaping now).
00527         """
00528         if do_escape is not None:
00529             if do_escape:
00530                 logging.warning("Deprecation warning: MoinMoin.formatter.text_html.url being called with do_escape=1/True parameter, please review caller.")
00531             else:
00532                 logging.warning("Deprecation warning: MoinMoin.formatter.text_html.url being called with do_escape=0/False parameter, please remove it from the caller.")
00533         if on:
00534             attrs = self._langAttr()
00535 
00536             # Handle the URL mapping
00537             if url is None and 'href' in kw:
00538                 url = kw['href']
00539                 del kw['href']
00540             if url is not None:
00541                 url = wikiutil.mapURL(self.request, url)
00542                 attrs['href'] = url
00543 
00544             if css:
00545                 attrs['class'] = css
00546 
00547             markup = self._open('a', attr=attrs, **kw)
00548         else:
00549             markup = self._close('a')
00550         return markup

Here is the call graph for this function:

Here is the caller graph for this function:


Member Data Documentation

Initial value:
{
        'table': ['class', 'id', 'style'],
        'row': ['class', 'id', 'style'],
        '': ['colspan', 'rowspan', 'class', 'id', 'style', 'abbr'],
    }

Reimplemented in MoinMoin.formatter.text_gedit.Formatter.

Definition at line 1181 of file text_html.py.

Reimplemented from MoinMoin.formatter.FormatterBase.

Reimplemented in MoinMoin.formatter.text_gedit.Formatter.

Definition at line 1135 of file text_html.py.

Definition at line 190 of file text_html.py.

Definition at line 191 of file text_html.py.

Definition at line 187 of file text_html.py.

Definition at line 188 of file text_html.py.

Definition at line 189 of file text_html.py.

Definition at line 185 of file text_html.py.

Definition at line 194 of file text_html.py.

Definition at line 192 of file text_html.py.

Definition at line 810 of file text_html.py.

Definition at line 196 of file text_html.py.

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 180 of file text_html.py.

Definition at line 38 of file __init__.py.

Definition at line 181 of file text_html.py.

Definition at line 197 of file text_html.py.

Reimplemented in MoinMoin.formatter.dom_xml.Formatter.

Definition at line 58 of file __init__.py.

Definition at line 193 of file text_html.py.

Definition at line 37 of file __init__.py.

Reimplemented from MoinMoin.formatter.FormatterBase.

Definition at line 195 of file text_html.py.

Reimplemented in MoinMoin.formatter.text_gedit.Formatter.

Definition at line 1008 of file text_html.py.


The documentation for this class was generated from the following file: