Changeset 1897:f4b44c5a59a5 in livinglogic.python.xist

Show
Ignore:
Timestamp:
07/10/03 20:29:45 (17 years ago)
Author:
Walter Doerwald <walter@…>
Branch:
default
Message:

Update the namespace example in the HOWTO.

Simplify the different conversions in ll.xist.ns.abbr. The various
properties of the abbr entitities are now defined via class attributes.
Add an element abbr to doc and make abbr entities convertable to doc.

ll.xist.ns.doc elements can now be converted to ll.xist.ns.fo elements.
This is used for the web site to automatically generate PDFs.

Files:
3 modified

Legend:

Unmodified
Added
Removed
  • HOWTO.xml

    r1889 r1897  
    313313<par>Now that you've defined your own elements, you have to 
    314314tell the parser about them, so they can be instantiated when 
    315 a file is parsed. This is done with namespace objects. At the end 
     315a file is parsed. This is done with namespace classes. At the end 
    316316of your Python module after all the classes are defined, create a 
    317 namespace object that collects all the class objects from the 
     317namespace class that collects all the class objects from the 
    318318local scope:</par> 
    319319<example> 
    320320<prog> 
    321 xmlns = xsc.Namespace( 
    322     "foo", 
    323     "http://www.foo.net/foo", 
    324     vars() 
    325 ) 
     321class xmlns(xsc.Namespace): 
     322    xmlname = "foo" 
     323    xmlurl = "http://www.foo.net/foo" 
     324xmlns.update(vars()) 
    326325</prog> 
    327326</example> 
     
    330329<pyref module="ll.xist.xsc" class="Namespace" method="__init__"><class>Namespace</class> constructor</pyref>.</par> 
    331330 
    332 <par>All defined namespace objects will automatically be registered with the 
     331<par>All defined namespace classes will automatically be registered with the 
    333332parser, so all defined elements will be used when parsing files.</par> 
    334333</section> 
  • _xist/ns/abbr.py

    r1693 r1897  
    1717 
    1818from ll.xist import xsc 
    19 import html as html_ 
    20 import docbook 
     19import doc 
    2120 
    2221class base(xsc.Entity): 
     
    2625    """ 
    2726    register = False 
     27    content = None 
     28    title = None 
     29    lang = None 
    2830 
    2931    def convert(self, converter): 
    30         target = converter.target 
    31         if issubclass(target, docbook): 
    32             e = self.convert_docbook(converter) 
    33         elif issubclass(target, html_): 
    34             e = self.convert_html(converter) 
    35         else: 
    36             raise ValueError("unknown conversion target %r" % target) 
    37         return e.convert(converter) 
     32        node = doc.abbr(self.__class__.content, title=self.__class__.title, lang=self.__class__.lang) 
     33        return node.convert(converter) 
     34 
     35    def __unicode__(self): 
     36        return unicode(self.content) 
    3837 
    3938class rmi(base): 
    40     def convert_docbook(self, converter): 
    41         return converter.target.abbrev("RMI", lang="en") 
    42     def convert_html(self, converter): 
    43         return converter.target.abbr("RMI", title="Remote Method Invocation", lang="en") 
    44     def __unicode__(self): 
    45         return u"RMI" 
     39    content = "RMI" 
     40    title = "Remote Method Invocation" 
     41    lang = "en" 
    4642 
    4743class jini(base): 
    48     def convert_docbook(self, converter): 
    49         return converter.target.abbrev("JINI", lang="en") 
    50     def convert_html(self, converter): 
    51         return converter.target.abbr("JINI", title="Java Intelligent Network Infrastructure", lang="en") 
    52     def __unicode__(self): 
    53         return u"JINI" 
     44    content = "JINI" 
     45    title = "Java Intelligent Network Infrastructure" 
     46    lang = "en" 
    5447 
    5548class jfc(base): 
    56     def convert_docbook(self, converter): 
    57         return converter.target.abbrev("JFC", lang="en") 
    58     def convert_html(self, converter): 
    59         return converter.target.abbr("JFC", title="Java Foundation Classes", lang="en") 
    60     def __unicode__(self): 
    61         return u"JFC" 
     49    content = "JFC" 
     50    title = "Java Foundation Classes" 
     51    lang = "en" 
    6252 
    6353class awt(base): 
    64     def convert_docbook(self, converter): 
    65         return converter.target.abbrev("AWT", lang="en") 
    66     def convert_html(self, converter): 
    67         return converter.target.abbr("AWT", title="Abstract Window Toolkit", lang="en") 
    68     def __unicode__(self): 
    69         return u"AWT" 
     54    content = "AWT" 
     55    title = "Abstract Window Toolkit" 
     56    lang = "en" 
    7057 
    7158class jdbc(base): 
    72     def convert_docbook(self, converter): 
    73         return converter.target.abbrev("JDBC", lang="en") 
    74     def convert_html(self, converter): 
    75         return converter.target.abbr("JDBC", title="Java Database Connectivity", lang="en") 
    76     def __unicode__(self): 
    77         return u"JDBC" 
     59    content = "JDBC" 
     60    title = "Java Database Connectivity" 
     61    lang = "en" 
    7862 
    7963class jndi(base): 
    80     def convert_docbook(self, converter): 
    81         return converter.target.abbrev("JNDI", lang="en") 
    82     def convert_html(self, converter): 
    83         return converter.target.abbr("JNDI", title="Java Naming and Directory Interface", lang="en") 
    84     def __unicode__(self): 
    85         return u"JNDI" 
     64    content = "JNDI" 
     65    title = "Java Naming and Directory Interface" 
     66    lang = "en" 
    8667 
    8768class jpda(base): 
    88     def convert_docbook(self, converter): 
    89         return converter.target.abbrev("JPDA", lang="en") 
    90     def convert_html(self, converter): 
    91         return converter.target.abbr("JPDA", title="Java Platform Debugger Architecture", lang="en") 
    92     def __unicode__(self): 
    93         return u"JPDA" 
     69    content = "JPDA" 
     70    title = "Java Platform Debugger Architecture" 
     71    lang = "en" 
    9472 
    9573class jvmpi(base): 
    96     def convert_docbook(self, converter): 
    97         return converter.target.abbrev("JVMPI", lang="en") 
    98     def convert_html(self, converter): 
    99         return converter.target.abbr("JVMPI", title="Java Virtual Machine Profiler Interface", lang="en") 
    100     def __unicode__(self): 
    101         return u"JVMPI" 
     74    content = "JVMPI" 
     75    title = "Java Virtual Machine Profiler Interface" 
     76    lang = "en" 
    10277 
    10378class jni(base): 
    104     def convert_docbook(self, converter): 
    105         return converter.target.abbrev("JNI", lang="en") 
    106     def convert_html(self, converter): 
    107         return converter.target.abbr("JNI", title="Java Native Interface", lang="en") 
    108     def __unicode__(self): 
    109         return u"JNI" 
     79    content = "JNI" 
     80    title = "Java Native Interface" 
     81    lang = "en" 
    11082 
    11183class ejb(base): 
    112     def convert_docbook(self, converter): 
    113         return converter.target.abbrev("EJB", lang="en") 
    114     def convert_html(self, converter): 
    115         return converter.target.abbr("EJB", title="Enterprice Java Beans", lang="en") 
    116     def __unicode__(self): 
    117         return u"EJB" 
     84    content = "EJB" 
     85    title = "Enterprice Java Beans" 
     86    lang = "en" 
    11887 
    11988class jnlp(base): 
    120     def convert_docbook(self, converter): 
    121         return converter.target.abbrev("JNLP", lang="en") 
    122     def convert_html(self, converter): 
    123         return converter.target.abbr("JNLP", title="Java Network Launch Protocol", lang="en") 
    124     def __unicode__(self): 
    125         return u"JNLP" 
     89    content = "JNLP" 
     90    title = "Java Network Launch Protocol" 
     91    lang = "en" 
    12692 
    12793class jaoe(base): 
    128     def convert_docbook(self, converter): 
    129         return converter.target.abbrev("JAOE", lang="en") 
    130     def convert_html(self, converter): 
    131         return converter.target.abbr("JAOE", title="Java Acronym Overflow Error", lang="en") 
    132     def __unicode__(self): 
    133         return u"jaoe" 
     94    content = "JAOE" 
     95    title = "Java Acronym Overflow Error" 
     96    lang = "en" 
    13497 
    13598class jgl(base): 
    136     def convert_docbook(self, converter): 
    137         return converter.target.abbrev("JGL", lang="en") 
    138     def convert_html(self, converter): 
    139         return converter.target.abbr("JGL", title="Java Generic Library", lang="en") 
    140     def __unicode__(self): 
    141         return u"JGL" 
     99    content = "JGL" 
     100    title = "Java Generic Library" 
     101    lang = "en" 
    142102 
    143103class sgml(base): 
    144     def convert_docbook(self, converter): 
    145         return converter.target.abbrev("SGML", lang="en") 
    146     def convert_html(self, converter): 
    147         return converter.target.abbr("SGML", title="Standard Generalized Markup Language", lang="en") 
    148     def __unicode__(self): 
    149         return u"SGML" 
     104    content = "SGML" 
     105    title = "Standard Generalized Markup Language" 
     106    lang = "en" 
    150107 
    151108class html(base): 
    152     def convert_docbook(self, converter): 
    153         return converter.target.abbrev("HTML", lang="en") 
    154     def convert_html(self, converter): 
    155         return converter.target.abbr("HTML", title="Hypertext Markup Language", lang="en") 
    156     def __unicode__(self): 
    157         return u"HTML" 
     109    content = "HTML" 
     110    title = "Hypertext Markup Language" 
     111    lang = "en" 
    158112 
    159113class xhtml(base): 
    160     def convert_docbook(self, converter): 
    161         return converter.target.abbrev("XHTML", lang="en") 
    162     def convert_html(self, converter): 
    163         return converter.target.abbr("XHTML") 
    164     def __unicode__(self): 
    165         return u"XHTML" 
     114    content = "XHTML" 
    166115 
    167116class xml(base): 
    168     def convert_docbook(self, converter): 
    169         return converter.target.abbrev("XML", lang="en") 
    170     def convert_html(self, converter): 
    171         return converter.target.abbr("XML", title="Extensible Markup Language", lang="en") 
    172     def __unicode__(self): 
    173         return u"XML" 
     117    content = "XML" 
     118    title = "Extensible Markup Language" 
     119    lang = "en" 
    174120 
    175121class css(base): 
    176     def convert_docbook(self, converter): 
    177         return converter.target.abbrev("CSS", lang="en") 
    178     def convert_html(self, converter): 
    179         return converter.target.abbr("CSS", title="Cascading Style Sheet", lang="en") 
    180     def __unicode__(self): 
    181         return u"CSS" 
     122    content = "CSS" 
     123    title = "Cascading Style Sheet" 
     124    lang = "en" 
    182125 
    183126class cgi(base): 
    184     def convert_docbook(self, converter): 
    185         return converter.target.abbrev("CGI", lang="en") 
    186     def convert_html(self, converter): 
    187         return converter.target.abbr("CGI", title="Common Gateway Interface", lang="en") 
    188     def __unicode__(self): 
    189         return u"CGI" 
     127    content = "CGI" 
     128    title = "Common Gateway Interface" 
     129    lang = "en" 
    190130 
    191131class www(base): 
    192     def convert_docbook(self, converter): 
    193         return converter.target.abbrev("WWW", lang="en") 
    194     def convert_html(self, converter): 
    195         return converter.target.abbr("WWW", title="World Wide Web", lang="en") 
    196     def __unicode__(self): 
    197         return u"WWW" 
     132    content = "WWW" 
     133    title = "World Wide Web" 
     134    lang = "en" 
    198135 
    199136class pdf(base): 
    200     def convert_docbook(self, converter): 
    201         return converter.target.abbrev("PDF", lang="en") 
    202     def convert_html(self, converter): 
    203         return converter.target.abbr("PDF", title="Protable Document Format", lang="en") 
    204     def __unicode__(self): 
    205         return u"PDF" 
     137    content = "PDF" 
     138    title = "Protable Document Format" 
     139    lang = "en" 
    206140 
    207141class url(base): 
    208     def convert_docbook(self, converter): 
    209         return converter.target.abbrev("URL", lang="en") 
    210     def convert_html(self, converter): 
    211         return converter.target.abbr("URL", title="Uniform Resource Locator", lang="en") 
    212     def __unicode__(self): 
    213         return u"URL" 
     142    content = "URL" 
     143    title = "Uniform Resource Locator" 
     144    lang = "en" 
    214145 
    215146class http(base): 
    216     def convert_docbook(self, converter): 
    217         return converter.target.abbrev("HTTP", lang="en") 
    218     def convert_html(self, converter): 
    219         return converter.target.abbr("HTTP", title="Hypertext Transfer Protocol", lang="en") 
    220     def __unicode__(self): 
    221         return u"HTTP" 
     147    content = "HTTP" 
     148    title = "Hypertext Transfer Protocol" 
     149    lang = "en" 
    222150 
    223151class smtp(base): 
    224     def convert_docbook(self, converter): 
    225         return converter.target.abbrev("SMTP", lang="en") 
    226     def convert_html(self, converter): 
    227         return converter.target.abbr("SMTP", title="Simple Mail Transfer Protocol", lang="en") 
    228     def __unicode__(self): 
    229         return u"SMTP" 
     152    content = "SMTP" 
     153    title = "Simple Mail Transfer Protocol" 
     154    lang = "en" 
    230155 
    231156class ftp(base): 
    232     def convert_docbook(self, converter): 
    233         return converter.target.abbrev("FTP", lang="en") 
    234     def convert_html(self, converter): 
    235         return converter.target.abbr("FTP", title="File Transfer Protocol", lang="en") 
    236     def __unicode__(self): 
    237         return u"FTP" 
     157    content = "FTP" 
     158    title = "File Transfer Protocol" 
     159    lang = "en" 
    238160 
    239161class pop3(base): 
    240     def convert_docbook(self, converter): 
    241         return converter.target.abbrev("POP3", lang="en") 
    242     def convert_html(self, converter): 
    243         return converter.target.abbr("POP3", title="Post Office Protocol 3", lang="en") 
    244     def __unicode__(self): 
    245         return u"POP3" 
     162    content = "POP3" 
     163    title = "Post Office Protocol 3" 
     164    lang = "en" 
    246165 
    247166class cvs(base): 
    248     def convert_docbook(self, converter): 
    249         return converter.target.abbrev("CVS", lang="en") 
    250     def convert_html(self, converter): 
    251         return converter.target.abbr("CVS", title="Concurrent Versions System", lang="en") 
    252     def __unicode__(self): 
    253         return u"CVS" 
     167    content = "CVS" 
     168    title = "Concurrent Versions System" 
     169    lang = "en" 
    254170 
    255171class faq(base): 
    256     def convert_docbook(self, converter): 
    257         return converter.target.abbrev("FAQ", lang="en") 
    258     def convert_html(self, converter): 
    259         return converter.target.abbr("FAQ", title="Frequently Asked Question", lang="en") 
    260     def __unicode__(self): 
    261         return u"FAQ" 
     172    content = "FAQ" 
     173    title = "Frequently Asked Question" 
     174    lang = "en" 
    262175 
    263176class gnu(base): 
    264     def convert_docbook(self, converter): 
    265         return converter.target.abbrev("GNU", lang="en") 
    266     def convert_html(self, converter): 
    267             # we could do it ;): return html_.abbr("GNU", title=(self, "'s Not UNIX"), lang="en") 
    268         return converter.target.abbr("GNU", title="GNU's Not UNIX", lang="en") 
    269     def __unicode__(self): 
    270         return u"GNU" 
     177    content = "GNU" 
     178    title = "GNU's Not UNIX" 
     179    lang = "en" 
    271180 
    272181class dns(base): 
    273     def convert_docbook(self, converter): 
    274         return converter.target.abbrev("DNS", lang="en") 
    275     def convert_html(self, converter): 
    276         return converter.target.abbr("DNS", title="Domain Name Service", lang="en") 
    277     def __unicode__(self): 
    278         return u"DNS" 
     182    content = "DNS" 
     183    title = "Domain Name Service" 
     184    lang = "en" 
    279185 
    280186class ppp(base): 
    281     def convert_docbook(self, converter): 
    282         return converter.target.abbrev("PPP", lang="en") 
    283     def convert_html(self, converter): 
    284         return converter.target.abbr("PPP", title="Point To Point Protocol", lang="en") 
    285     def __unicode__(self): 
    286         return u"PPP" 
     187    content = "PPP" 
     188    title = "Point To Point Protocol" 
     189    lang = "en" 
    287190 
    288191class isdn(base): 
    289     def convert_docbook(self, converter): 
    290         return converter.target.abbrev("ISDN", lang="en") 
    291     def convert_html(self, converter): 
    292         return converter.target.abbr("ISDN", title="Integrated Services Digital Network", lang="en") 
    293     def __unicode__(self): 
    294         return u"ISDN" 
     192    content = "ISDN" 
     193    title = "Integrated Services Digital Network" 
     194    lang = "en" 
    295195 
    296196class corba(base): 
    297     def convert_docbook(self, converter): 
    298         return converter.target.abbrev("CORBA", lang="en") 
    299     def convert_html(self, converter): 
    300         return converter.target.abbr("CORBA", title="Common Object Request Broker Architecture", lang="en") 
    301     def __unicode__(self): 
    302         return u"CORBA" 
     197    content = "CORBA" 
     198    title = "Common Object Request Broker Architecture" 
     199    lang = "en" 
    303200 
    304201class wap(base): 
    305     def convert_docbook(self, converter): 
    306         return converter.target.abbrev("WAP", lang="en") 
    307     def convert_html(self, converter): 
    308         return converter.target.abbr("WAP", title="Wireless Application Protocol", lang="en") 
    309     def __unicode__(self): 
    310         return u"WAP" 
     202    content = "WAP" 
     203    title = "Wireless Application Protocol" 
     204    lang = "en" 
    311205 
    312206class wml(base): 
    313     def convert_docbook(self, converter): 
    314         return converter.target.abbrev("WML", lang="en") 
    315     def convert_html(self, converter): 
    316         return converter.target.abbr("WML", title="Wireless Markup Language", lang="en") 
    317     def __unicode__(self): 
    318         return u"WML" 
     207    content = "WML" 
     208    title = "Wireless Markup Language" 
     209    lang = "en" 
    319210 
    320211class mac(base): 
    321     def convert_docbook(self, converter): 
    322         return converter.target.abbrev("MAC", lang="en") 
    323     def convert_html(self, converter): 
    324         return converter.target.abbr("MAC", title="Media Access Control", lang="en") 
    325     def __unicode__(self): 
    326         return u"MAC" 
     212    content = "MAC" 
     213    title = "Media Access Control" 
     214    lang = "en" 
    327215 
    328216class nat(base): 
    329     def convert_docbook(self, converter): 
    330         return converter.target.abbrev("NAT", lang="en") 
    331     def convert_html(self, converter): 
    332         return converter.target.abbr("NAT", title="Network Address Translation", lang="en") 
    333     def __unicode__(self): 
    334         return u"NAT" 
     217    content = "NAT" 
     218    title = "Network Address Translation" 
     219    lang = "en" 
    335220 
    336221class sql(base): 
    337     def convert_docbook(self, converter): 
    338         return converter.target.abbrev("SQL", lang="en") 
    339     def convert_html(self, converter): 
    340         return converter.target.abbr("SQL", title="Structured Query Language", lang="en") 
    341     def __unicode__(self): 
    342         return u"SQL" 
     222    content = "SQL" 
     223    title = "Structured Query Language" 
     224    lang = "en" 
    343225 
    344226class xsl(base): 
    345     def convert_docbook(self, converter): 
    346         return converter.target.abbrev("XSL", lang="en") 
    347     def convert_html(self, converter): 
    348         return converter.target.abbr("XSL", title="Extensible Stylesheet Language", lang="en") 
    349     def __unicode__(self): 
    350         return u"XSL" 
     227    content = "XSL" 
     228    title = "Extensible Stylesheet Language" 
     229    lang = "en" 
    351230 
    352231class xslt(base): 
    353     def convert_docbook(self, converter): 
    354         return converter.target.abbrev("XSLT", lang="en") 
    355     def convert_html(self, converter): 
    356         return converter.target.abbr("XSLT", title="Extensible Stylesheet Language For Transformations", lang="en") 
    357     def __unicode__(self): 
    358         return u"XSLT" 
     232    content = "XSLT" 
     233    title = "Extensible Stylesheet Language For Transformations" 
     234    lang = "en" 
    359235 
    360236class smil(base): 
    361     def convert_docbook(self, converter): 
    362         return converter.target.abbrev("SMIL", lang="en") 
    363     def convert_html(self, converter): 
    364         return converter.target.abbr("SMIL", title="Synchronized Multimedia Integration Language", lang="en") 
    365     def __unicode__(self): 
    366         return u"SMIL" 
     237    content = "SMIL" 
     238    title = "Synchronized Multimedia Integration Language" 
     239    lang = "en" 
    367240 
    368241class dtd(base): 
    369     def convert_docbook(self, converter): 
    370         return converter.target.abbrev("DTD", lang="en") 
    371     def convert_html(self, converter): 
    372         return converter.target.abbr("DTD", title="Document Type Definiton", lang="en") 
    373     def __unicode__(self): 
    374         return u"DTD" 
     242    content = "DTD" 
     243    title = "Document Type Definiton" 
     244    lang = "en" 
    375245 
    376246class dom(base): 
    377     def convert_docbook(self, converter): 
    378         return converter.target.abbrev("DOM", lang="en") 
    379     def convert_html(self, converter): 
    380         return converter.target.abbr("DOM", title="Document Object Model", lang="en") 
    381     def __unicode__(self): 
    382         return u"DOM" 
     247    content = "DOM" 
     248    title = "Document Object Model" 
     249    lang = "en" 
    383250 
    384251class api(base): 
    385     def convert_docbook(self, converter): 
    386         return converter.target.abbrev("API", lang="en") 
    387     def convert_html(self, converter): 
    388         return converter.target.abbr("API", title="Application Programming Interface", lang="en") 
    389     def __unicode__(self): 
    390         return u"API" 
     252    content = "API" 
     253    title = "Application Programming Interface" 
     254    lang = "en" 
    391255 
    392256class sax(base): 
    393     def convert_docbook(self, converter): 
    394         return converter.target.abbrev("SAX", lang="en") 
    395     def convert_html(self, converter): 
    396         return converter.target.abbr("SAX", title=("Simple ", self.xmlns.api(), " for ", self.xmlns.xml()), lang="en").convert(converter) 
    397     def __unicode__(self): 
    398         return u"SAX" 
     257    content = "SAX" 
     258    title = ("Simple ", api(), " for ", xml()) 
     259    lang = "en" 
    399260 
    400261class dbms(base): 
    401     def convert_docbook(self, converter): 
    402         return converter.target.abbrev("DBMS", lang="en") 
    403     def convert_html(self, converter): 
    404         return converter.target.abbr("DBMS", title="Database Management System", lang="en") 
    405     def __unicode__(self): 
    406         return u"DBMS" 
     262    content = "DBMS" 
     263    title = "Database Management System" 
     264    lang = "en" 
    407265 
    408266class ansi(base): 
    409     def convert_docbook(self, converter): 
    410         return converter.target.abbrev("ANSI", lang="en") 
    411     def convert_html(self, converter): 
    412         return converter.target.abbr("ANSI", title="American National Standards Institute", lang="en") 
    413     def __unicode__(self): 
    414         return u"ANSI" 
     267    content = "ANSI" 
     268    title = "American National Standards Institute" 
     269    lang = "en" 
    415270 
    416271class jsp(base): 
    417     def convert_docbook(self, converter): 
    418         return converter.target.abbrev("JSP", lang="en") 
    419     def convert_html(self, converter): 
    420         return converter.target.abbr("JSP", title="Java Server Pages", lang="en") 
    421     def __unicode__(self): 
    422         return u"JSP" 
     272    content = "JSP" 
     273    title = "Java Server Pages" 
     274    lang = "en" 
    423275 
    424276class ascii(base): 
    425     def convert_docbook(self, converter): 
    426         return converter.target.abbrev("ASCII", lang="en") 
    427     def convert_html(self, converter): 
    428         return converter.target.abbr("ASCII", title="American Standard Code for Information Interchange", lang="en") 
    429     def __unicode__(self): 
    430         return u"ASCII" 
     277    content = "ASCII" 
     278    title = "American Standard Code for Information Interchange" 
     279    lang = "en" 
    431280 
    432281class sms(base): 
    433     def convert_docbook(self, converter): 
    434         return converter.target.abbrev("SMS", lang="en") 
    435     def convert_html(self, converter): 
    436         return converter.target.abbr("SMS", title="Small Message Service", lang="en") 
    437     def __unicode__(self): 
    438         return u"SMS" 
     282    content = "SMS" 
     283    title = "Small Message Service" 
     284    lang = "en" 
    439285 
    440286class p2p(base): 
    441     def convert_docbook(self, converter): 
    442         return converter.target.abbrev("P2P", lang="en") 
    443     def convert_html(self, converter): 
    444         return converter.target.abbr("P2P", title="Peer To Peer", lang="en") 
    445     def __unicode__(self): 
    446         return u"P2P" 
     287    content = "P2P" 
     288    title = "Peer To Peer" 
     289    lang = "en" 
    447290 
    448291class gif(base): 
    449     def convert_docbook(self, converter): 
    450         return converter.target.abbrev("GIF", lang="en") 
    451     def convert_html(self, converter): 
    452         return converter.target.abbr("GIF", title="Graphics Interchange Format", lang="en") 
    453     def __unicode__(self): 
    454         return u"GIF" 
     292    content = "GIF" 
     293    title = "Graphics Interchange Format" 
     294    lang = "en" 
    455295 
    456296class png(base): 
    457     def convert_docbook(self, converter): 
    458         return converter.target.abbrev("PNG", lang="en") 
    459     def convert_html(self, converter): 
    460         return converter.target.abbr("PNG", title="Portable Network Graphics", lang="en") 
    461     def __unicode__(self): 
    462         return u"PNG" 
     297    content = "PNG" 
     298    title = "Portable Network Graphics" 
     299    lang = "en" 
    463300 
    464301class uddi(base): 
    465     def convert_docbook(self, converter): 
    466         return converter.target.abbrev("UDDI", lang="en") 
    467     def convert_html(self, converter): 
    468         return converter.target.abbr("UDDI", title="Universal Description, Discovery and Integration", lang="en") 
    469     def __unicode__(self): 
    470         return u"UDDI" 
     302    content = "UDDI" 
     303    title = "Universal Description, Discovery and Integration" 
     304    lang = "en" 
    471305 
    472306class wsdl(base): 
    473     def convert_docbook(self, converter): 
    474         return converter.target.abbrev("WSDL", lang="en") 
    475     def convert_html(self, converter): 
    476         return converter.target.abbr("WSDL", title="Web Services Description Language", lang="en") 
    477     def __unicode__(self): 
    478         return u"WSDL" 
     307    content = "WSDL" 
     308    title = "Web Services Description Language" 
     309    lang = "en" 
    479310 
    480311class cdrom(base): 
    481     def convert_docbook(self, converter): 
    482         return converter.target.abbrev("CDROM", lang="en") 
    483     def convert_html(self, converter): 
    484         return converter.target.abbr("CDROM") 
    485     def __unicode__(self): 
    486         return u"CDROM" 
     312    content = "CDROM" 
    487313 
    488314class snmp(base): 
    489     def convert_docbook(self, converter): 
    490         return converter.target.abbrev("SNMP", lang="en") 
    491     def convert_html(self, converter): 
    492         return converter.target.abbr("SNMP", title="Simple Network Management Protocol", lang="en") 
    493     def __unicode__(self): 
    494         return u"SNMP" 
     315    content = "SNMP" 
     316    title = "Simple Network Management Protocol" 
     317    lang = "en" 
    495318 
    496319class ssl(base): 
    497     def convert_docbook(self, converter): 
    498         return converter.target.abbrev("SSL", lang="en") 
    499     def convert_html(self, converter): 
    500         return converter.target.abbr("SSL", title="Secure Socket Layer", lang="en") 
    501     def __unicode__(self): 
    502         return u"SSL" 
     320    content = "SSL" 
     321    title = "Secure Socket Layer" 
     322    lang = "en" 
    503323 
    504324class vrml(base): 
    505     def convert_docbook(self, converter): 
    506         return converter.target.abbrev("VRML", lang="en") 
    507     def convert_html(self, converter): 
    508         return converter.target.abbr("VRML", title="Virtual Reality Modelling Language", lang="en") 
    509     def __unicode__(self): 
    510         return u"VRML" 
     325    content = "VRML" 
     326    title = "Virtual Reality Modelling Language" 
     327    lang = "en" 
    511328 
    512329class tco(base): 
    513     def convert_docbook(self, converter): 
    514         return converter.target.abbrev("TCO", lang="en") 
    515     def convert_html(self, converter): 
    516         return converter.target.abbr("TCO", title="Total Cost of Ownership", lang="en") 
    517     def __unicode__(self): 
    518         return u"TCO" 
     330    content = "TCO" 
     331    title = "Total Cost of Ownership" 
     332    lang = "en" 
    519333 
    520334class crm(base): 
    521     def convert_docbook(self, converter): 
    522         return converter.target.abbrev("CRM", lang="en") 
    523     def convert_html(self, converter): 
    524         return converter.target.abbr("CRM", title="Customer Relationship Management", lang="en") 
    525     def __unicode__(self): 
    526         return u"CRM" 
     335    content = "CRM" 
     336    title = "Customer Relationship Management" 
     337    lang = "en" 
    527338 
    528339class cms(base): 
    529     def convert_docbook(self, converter): 
    530         return converter.target.abbrev("CMS", lang="en") 
    531     def convert_html(self, converter): 
    532         return converter.target.abbr("CMS", title="Content Management System", lang="en") 
    533     def __unicode__(self): 
    534         return u"CMS" 
     340    content = "CMS" 
     341    title = "Content Management System" 
     342    lang = "en" 
    535343 
    536344class bnf(base): 
    537     def convert_docbook(self, converter): 
    538         return converter.target.abbrev("BNF", lang="en") 
    539     def convert_html(self, converter): 
    540         return converter.target.abbr("BNF", title="Backus Naur Form", lang="en") 
    541     def __unicode__(self): 
    542         return u"BNF" 
     345    content = "BNF" 
     346    title = "Backus Naur Form" 
     347    lang = "en" 
    543348 
    544349class mime(base): 
    545     def convert_docbook(self, converter): 
    546         return converter.target.abbrev("MIME", lang="en") 
    547     def convert_html(self, converter): 
    548         return converter.target.abbr("MIME", title="Multipurpose Internet Mail Extensions", lang="en") 
    549     def __unicode__(self): 
    550         return u"MIME" 
     350    content = "MIME" 
     351    title = "Multipurpose Internet Mail Extensions" 
     352    lang = "en" 
    551353 
    552354class wysiwyg(base): 
    553     def convert_docbook(self, converter): 
    554         return converter.target.abbrev("WYSIWYG", lang="en") 
    555     def convert_html(self, converter): 
    556         return converter.target.abbr("WYSIWYG", title="What You See Is What You Get", lang="en") 
    557     def __unicode__(self): 
    558         return u"WYSIWYG" 
     355    content = "WYSIWYG" 
     356    title = "What You See Is What You Get" 
     357    lang = "en" 
    559358 
    560359class hsc(base): 
    561     def convert(self, converter): 
    562         return xsc.Text("HSC") 
    563     def __unicode__(self): 
    564         return u"HSC" 
     360    content = "HSC" 
    565361 
    566362class xist(base): 
    567     def convert(self, converter): 
    568         return xsc.Text("XIST") 
    569     def __unicode__(self): 
    570         return u"XIST" 
     363    content = "XIST" 
    571364 
    572365class xist4c(base): 
    573     def convert(self, converter): 
    574         return xsc.Text("XIST4C") 
    575     def __unicode__(self): 
    576         return u"XIST4C" 
     366    content = "XIST4C" 
    577367 
    578368class php(base): 
    579     def convert(self, converter): 
    580         return xsc.Text("PHP") 
    581     def __unicode__(self): 
    582         return u"PHP" 
     369    content = "PHP" 
    583370 
    584371class svg(base): 
    585     def convert_docbook(self, converter): 
    586         return converter.target.abbrev("SVG", lang="en") 
    587     def convert_html(self, converter): 
    588         return converter.target.abbr("SVG", title="Scalable Vector Graphics", lang="en") 
    589     def __unicode__(self): 
    590         return u"SVG" 
     372    content = "SVG" 
     373    title = "Scalable Vector Graphics" 
     374    lang = "en" 
    591375 
    592376class utc(base): 
    593     def convert_docbook(self, converter): 
    594         return converter.target.abbrev("UTC", lang="en") 
    595     def convert_html(self, converter): 
    596         return converter.target.abbr("UTC", title="Coordinated Universal Time", lang="en") 
    597     def __unicode__(self): 
    598         return u"UTC" 
     377    content = "UTC" 
     378    title = "Coordinated Universal Time" 
     379    lang = "en" 
    599380 
    600381class xmlns(xsc.Namespace): 
  • _xist/ns/doc.py

    r1858 r1897  
    1010 
    1111# import __builtin__ to use property, which is also defined here 
    12 import types, inspect, __builtin__ 
    13  
    14 from ll.xist import xsc, parsers, errors 
    15 from ll.xist.ns import html, text, docbook 
     12import types, inspect, warnings, __builtin__ 
     13 
     14from ll.xist import xsc, parsers, converters 
     15from ll.xist.ns import html, text, docbook, fo, specials, xml 
    1616 
    1717class base(xsc.Element): 
     
    2222    register = False 
    2323    empty = False 
     24 
     25    class Context(xsc.Element.Context): 
     26        def __init__(self): 
     27            xsc.Element.Context.__init__(self) 
     28            self.sections = [0] 
     29            self.lists = [] 
     30 
     31            self.llblue = "#006499" 
     32            self.llgreen = "#9fc94d" 
     33 
     34            self.ttfont = "CourierNew, monospace" 
     35            self.hdfont = "ArialNarrow, Arial, sans-serif" 
     36            self.font = "PalatinoLinotype, serif" 
     37 
     38            self.indentcount = 0 
     39 
     40            self.vspaceattrs = { 
     41                "space_before": "0pt", 
     42                "space_after_minimum": "4pt", 
     43                "space_after_optimum": "6pt", 
     44                "space_after_maximum": "12pt", 
     45                "space_after_conditionality": "discard", 
     46            } 
     47 
     48            self.linkattrs = { 
     49                "color": "blue", 
     50                "text_decoration": "underline" 
     51            } 
     52 
     53            self.codeattrs = { 
     54                "font_family": self.ttfont 
     55            } 
     56 
     57            self.repattrs = { 
     58                "font_style": "italic" 
     59            } 
     60 
     61            self.emattrs = { 
     62                "font_weight": "bold" 
     63            } 
     64 
     65            self.lists = [] 
     66            self.sections = [0] 
     67 
     68        def dedent(self): 
     69            return "-0.7cm" 
     70 
     71        def indent(self): 
     72            return "%.1fcm" % (0.7*self.indentcount) 
     73 
     74        def labelindent(self): 
     75            return "%.1fcm" % (0.7*self.indentcount-0.4) 
    2476 
    2577    def convert(self, converter): 
    2678        target = converter.target 
    2779        if issubclass(target, docbook): 
    28             e = self.convert_docbook(converter) 
     80            return self.convert_docbook(converter) 
     81        elif issubclass(target, text): 
     82            return self.convert_text(converter) 
    2983        elif issubclass(target, html): 
    30             e = self.convert_html(converter) 
     84            return self.convert_html(converter) 
     85        elif issubclass(target, xmlns): # our own namespace 
     86            return self.convert_doc(converter) 
     87        elif issubclass(target, fo): # our own namespace 
     88            return self.convert_fo(converter) 
    3189        else: 
    3290            raise ValueError("unknown conversion target %r" % target) 
    33         return e.convert(converter) 
     91 
     92    def convert_text(self, converter): 
     93        # Forward to the HTML conversion 
     94        return self.convert_html(converter) 
     95 
     96    def convert_doc(self, converter): 
     97        e = self.__class__( 
     98            self.content.convert(converter), 
     99            self.attrs.convert(converter) 
     100        ) 
     101        return e 
     102 
     103    def xconvert_fo(self, converter): 
     104        e = self.content.convert(converter) 
     105        return e 
    34106 
    35107class block(base): 
     
    39111    register = False 
    40112 
     113class abbr(base): 
     114    empty = False 
     115    class Attrs(xsc.Element.Attrs): 
     116        class title(xsc.TextAttr): pass 
     117        class lang(xsc.TextAttr): pass 
     118 
     119    def convert_docbook(self, converter): 
     120        e = converter.target.abbrev(self.content, lang=self["lang"]) 
     121        return e.convert(converter) 
     122 
     123    def convert_html(self, converter): 
     124        e = converter.target.abbr(self.content, self.attrs) 
     125        return e.convert(converter) 
     126 
     127    def convert_fo(self, converter): 
     128        return xsc.Text(unicode(self.content)) 
     129 
     130    def __unicode__(self): 
     131        return unicode(self.content) 
     132 
    41133class prog(block): 
    42134    """ 
     
    46138 
    47139    def convert_docbook(self, converter): 
    48         return converter.target.prog(self.content) 
     140        e = converter.target.programlisting(self.content) 
     141        return e.convert(converter) 
    49142 
    50143    def convert_html(self, converter): 
     
    56149                for c in child.content: 
    57150                    if c==u"\t": 
    58                         if issubclass(target, text): 
    59                             c = "   " 
    60                         else: 
    61                             c = target.span(u"···", class_="tab") 
     151                        c = target.span(u"···", class_="tab") 
    62152                    e.append(c) 
    63153            else: 
    64154                e.append(child) 
    65         if issubclass(target, text): 
    66             e = target.blockquote(e) 
    67         return e 
     155        return e.convert(converter) 
     156 
     157    def convert_text(self, converter): 
     158        target = converter.target 
     159        e = target.pre(class_="prog") 
     160        for child in self.content: 
     161            child = child.convert(converter) 
     162            if isinstance(child, xsc.Text): 
     163                for c in child.content: 
     164                    if c==u"\t": 
     165                        c = "   " 
     166                    e.append(c) 
     167            else: 
     168                e.append(child) 
     169        e = target.blockquote(e) 
     170        return e.convert(converter) 
     171 
     172    def convert_fo(self, converter): 
     173        target = converter.target 
     174        context = converter[base] 
     175        context.indentcount += 1 
     176        e = target.block( 
     177            context.vspaceattrs, 
     178            context.codeattrs, 
     179            text_align="left", 
     180            line_height="130%", 
     181            font_size="90%", 
     182            start_indent=context.indent(), 
     183            end_indent=context.indent() 
     184        ) 
     185        collect = target.block() 
     186        first = True 
     187        for child in self.content: 
     188            child = child.convert(converter) 
     189            if isinstance(child, xsc.Text): 
     190                for c in child.content: 
     191                    # We have to do the following, because FOP doesn't support the white-space property yet 
     192                    if c==u" ": 
     193                        c = u"\xa0" # transform spaces into nbsps 
     194                    if c==u"\t": 
     195                        c = target.inline(u"\u25ab", 3*u"\xa0", color="rgb(50%, 50%, 50%)") 
     196                    if c==u"\n": 
     197                        if not collect and not first: # fix empty lines (but not the first one) 
     198                            collect.append(u"\ufeff") 
     199                            collect["line_height"] = "60%" # reduce the line-height 
     200                        e.append(collect) 
     201                        collect = target.block() 
     202                        first = False 
     203                    else: 
     204                        collect.append(c) 
     205            else: 
     206                collect.append(child) 
     207        if collect: 
     208            e.append(collect) 
     209        context.indentcount -= 1 
     210        return e.convert(converter) 
    68211 
    69212class programlisting(prog): 
    70213    def convert(self, converter): 
    71         errors.warn(DeprecationWarning("programlisting is deprecated, use prog instead")) 
     214        warnings.warn(DeprecationWarning("programlisting is deprecated, use prog instead")) 
    72215        return prog.convert(self, converter) 
    73216 
     
    78221    empty = False 
    79222 
    80     def convert(self, converter): 
     223    def convert_docbook(self, converter): 
     224        e = converter.target.example(self.content) 
     225        return e.convert(converter) 
     226 
     227    def convert_html(self, converter): 
    81228        target = converter.target 
    82229        ts = xsc.Frag() 
    83         cs = xsc.Frag() 
     230        e = xsc.Frag() 
     231        for child in self: 
     232            if isinstance(child, title): 
     233                ts.append(child) 
     234            else: 
     235                e.append(child) 
     236 
     237        if ts: 
     238            e.append(target.div(ts, class_="example-title")) 
     239 
     240        return e.convert(converter) 
     241 
     242    def convert_text(self, converter): 
     243        target = converter.target 
     244        e = xsc.Frag() 
     245        for child in self.content: 
     246            if not isinstance(child, title): 
     247                e.append(child) 
     248 
     249        return e.convert(converter) 
     250 
     251    def convert_fo(self, converter): 
     252        # FIXME handle title 
     253        e = xsc.Frag() 
     254        for child in self.content: 
     255            if not isinstance(child, title): 
     256                e.append(child) 
     257        return e.convert(converter) 
     258 
     259class code(base): 
     260    register = False 
     261 
     262    def convert_fo(self, converter): 
     263        e = converter.target.inline( 
     264            self.content, 
     265            converter[base].codeattrs 
     266        ) 
     267        return e.convert(converter) 
     268 
     269class option(code): 
     270    """ 
     271    An option for a software command 
     272    """ 
     273    empty = False 
     274 
     275    def convert_docbook(self, converter): 
     276        e = converter.target.option(self.content) 
     277        return e.convert(converter) 
     278 
     279    def convert_html(self, converter): 
     280        e = converter.target.code(self.content, class_="option") 
     281        return e.convert(converter) 
     282 
     283class lit(code): 
     284    """ 
     285    Inline text that is some literal value 
     286    """ 
     287    empty = False 
     288 
     289    def convert_docbook(self, converter): 
     290        e = converter.target.literal(self.content) 
     291        return e.convert(converter) 
     292 
     293    def convert_html(self, converter): 
     294        e = converter.target.code(self.content, class_="literal") 
     295        return e.convert(converter) 
     296 
     297class function(code): 
     298    """ 
     299    The name of a function or subroutine, as in a programming language 
     300    """ 
     301    empty = False 
     302 
     303    def convert_docbook(self, converter): 
     304        e = converter.target.function(self.content) 
     305        return e.convert(converter) 
     306 
     307    def convert_html(self, converter): 
     308        e = converter.target.code(self.content, class_="function") 
     309        return e.convert(converter) 
     310 
     311class method(code): 
     312    """ 
     313    The name of a method or memberfunction in a programming language 
     314    """ 
     315    empty = False 
     316 
     317    def convert_docbook(self, converter): 
     318        e = converter.target.methodname(self.content) 
     319        return e.convert(converter) 
     320 
     321    def convert_html(self, converter): 
     322        e = converter.target.code(self.content, class_="method") 
     323        return e.convert(converter) 
     324 
     325class property(code): 
     326    """ 
     327    The name of a property in a programming language 
     328    """ 
     329    empty = False 
     330 
     331    def convert_docbook(self, converter): 
     332        e = converter.target.varname(self.content, role="property") 
     333        return e.convert(converter) 
     334 
     335    def convert_html(self, converter): 
     336        e = converter.target.code(self.content, class_="property") 
     337        return e.convert(converter) 
     338 
     339class class_(code): 
     340    """ 
     341    The name of a class, in the object-oriented programming sense 
     342    """ 
     343    xmlname = "class" 
     344    empty = False 
     345 
     346    def convert_docbook(self, converter): 
     347        e = converter.target.classname(self.content) 
     348        return e.convert(converter) 
     349 
     350    def convert_html(self, converter): 
     351        e = converter.target.code(self.content, class_="class") 
     352        return e.convert(converter) 
     353 
     354class rep(base): 
     355    """ 
     356    Content that may or must be replaced by the user 
     357    """ 
     358    empty = False 
     359 
     360    def convert_docbook(self, converter): 
     361        e = converter.target.replaceable(self.content) 
     362        return e.convert(converter) 
     363 
     364    def convert_html(self, converter): 
     365        e = converter.target.var(self.content, class_="rep") 
     366        return e.convert(converter) 
     367 
     368    def convert_fo(self, converter): 
     369        e = converter.target.inline(self.content, converter[base].repattrs) 
     370        return e.convert(converter) 
     371 
     372class markup(code): 
     373    """ 
     374    A string of formatting markup in text that is to be represented literally 
     375    """ 
     376    empty = False 
     377 
     378    def convert_docbook(self, converter): 
     379        e = converter.target.markup(self.content) 
     380        return e.convert(converter) 
     381 
     382    def convert_html(self, converter): 
     383        e = converter.target.code(self.content, class_="markup") 
     384        return e.convert(converter) 
     385 
     386class arg(code): 
     387    """ 
     388    The name of a function or method argument. 
     389    """ 
     390    empty = False 
     391 
     392    def convert_docbook(self, converter): 
     393        e = converter.target.parameter(self.content) 
     394        return e.convert(converter) 
     395 
     396    def convert_html(self, converter): 
     397        e = converter.target.code(self.content, class_="arg") 
     398        return e.convert(converter) 
     399 
     400class module(code): 
     401    """ 
     402    The name of Python module. 
     403    """ 
     404    empty = False 
     405 
     406    def convert_docbook(self, converter): 
     407        e = converter.target.classname(self.content, role="module") 
     408        return e.convert(converter) 
     409 
     410    def convert_html(self, converter): 
     411        e = converter.target.code(self.content, class_="module") 
     412        return e.convert(converter) 
     413 
     414class parameter(code): 
     415    """ 
     416    A value or a symbolic reference to a value 
     417    """ 
     418    empty = False 
     419 
     420    def convert_docbook(self, converter): 
     421        e = converter.target.parameter(self.content) 
     422        return e.convert(converter) 
     423 
     424    def convert_html(self, converter): 
     425        e = converter.target.code(self.content, class_="parameter") 
     426        return e.convert(converter) 
     427 
     428class filename(code): 
     429    """ 
     430    The name of a file 
     431    """ 
     432    empty = False 
     433 
     434    def convert_docbook(self, converter): 
     435        e = converter.target.filename(self.content) 
     436        return e.convert(converter) 
     437 
     438    def convert_html(self, converter): 
     439        e = converter.target.code(self.content, class_="filename") 
     440        return e.convert(converter) 
     441 
     442class dirname(code): 
     443    """ 
     444    The name of directory 
     445    """ 
     446    empty = False 
     447 
     448    def convert_docbook(self, converter): 
     449        e = converter.target.filename(self.content, class_="directory") 
     450        return e.convert(converter) 
     451 
     452    def convert_html(self, converter): 
     453        e = converter.target.code(self.content, class_="dirname") 
     454        return e.convert(converter) 
     455 
     456class username(code): 
     457    """ 
     458    The name of a user account 
     459    """ 
     460    empty = False 
     461 
     462    def convert_docbook(self, converter): 
     463        e = converter.target.literal(self.content, role="username") 
     464        return e.convert(converter) 
     465 
     466    def convert_html(self, converter): 
     467        e = converter.target.code(self.content, class_="username") 
     468        return e.convert(converter) 
     469 
     470class app(base): 
     471    """ 
     472    The name of a software program 
     473    """ 
     474    empty = False 
     475    class Attrs(xsc.Element.Attrs): 
     476        class moreinfo(xsc.URLAttr): pass 
     477 
     478    def convert_docbook(self, converter): 
     479        e = converter.target.application(self.content, moreinfo=self["moreinfo"]) 
     480        return e.convert(converter) 
     481 
     482    def convert_html(self, converter): 
     483        if "moreinfo" in self.attrs: 
     484            e = converter.target.a(self.content, class_="app", href=self["moreinfo"]) 
     485        else: 
     486            e = converter.target.span(self.content, class_="app") 
     487        return e.convert(converter) 
     488 
     489    def convert_fo(self, converter): 
     490        if "moreinfo" in self.attrs: 
     491            e = converter.target.basic_link( 
     492                self.content, 
     493                converter[base].linkattrs, 
     494                external_destination=self["moreinfo"] 
     495            ) 
     496        else: 
     497            e = self.content 
     498        return e.convert(converter) 
     499 
     500class title(base): 
     501    """ 
     502    The text of the title of a section of a document or of a formal block-level element 
     503    """ 
     504    empty = False 
     505 
     506    def convert_docbook(self, converter): 
     507        e = converter.target.title(self.content.convert(converter)) 
     508        return e.convert(converter) 
     509 
     510    def convert_html(self, converter): 
     511        e = self.content 
     512        return e.convert(converter) 
     513 
     514    def convert_fo(self, converter): 
     515        e = self.content 
     516        return e.convert(converter) 
     517 
     518class section(block): 
     519    """ 
     520    A recursive section 
     521    """ 
     522    empty = False 
     523    class Attrs(xsc.Element.Attrs): 
     524        class role(xsc.TextAttr): pass 
     525        class id(xsc.IDAttr): pass 
     526 
     527    def convert_docbook(self, converter): 
     528        e = converter.target.section(self.content, role=self["role"], id=self["id"]) 
     529        return e.convert(converter) 
     530 
     531    def convert_html(self, converter): 
     532        target = converter.target 
     533        context = converter[base] 
     534        context.sections[-1] += 1 
     535        level = len(context.sections) 
     536        context.sections.append(0) # for numbering the subsections 
     537        ts = xsc.Frag() 
     538        cs = target.div(class_=("section level", level)) 
     539        if "role" in self.attrs: 
     540            cs["class_"].append(" ", self.attrs["role"]) 
    84541        for child in self: 
    85542            if isinstance(child, title): 
     
    87544            else: 
    88545                cs.append(child) 
    89          
    90         if issubclass(target, docbook): 
    91             e = target.example(ts, cs) 
    92         elif issubclass(target, html): 
    93             e = cs 
    94             if issubclass(target, text) and ts: 
    95                 e.append(target.div(ts, class_="example-title")) 
    96         return e.convert(converter) 
    97  
    98 class option(base): 
    99     """ 
    100     An option for a software command 
    101     """ 
    102     empty = False 
    103  
    104     def convert_docbook(self, converter): 
    105         return converter.target.option(self.content) 
    106  
    107     def convert_html(self, converter): 
    108         return converter.target.code(self.content, class_="option") 
    109  
    110 class lit(base): 
    111     """ 
    112     Inline text that is some literal value 
    113     """ 
    114     empty = False 
    115  
    116     def convert_docbook(self, converter): 
    117         return converter.target.literal(self.content) 
    118  
    119     def convert_html(self, converter): 
    120         return converter.target.code(self.content, class_="literal") 
    121  
    122 class function(base): 
    123     """ 
    124     The name of a function or subroutine, as in a programming language 
    125     """ 
    126     empty = False 
    127  
    128     def convert_docbook(self, converter): 
    129         return converter.target.function(self.content) 
    130  
    131     def convert_html(self, converter): 
    132         return converter.target.code(self.content, class_="function") 
    133  
    134 class method(base): 
    135     """ 
    136     The name of a method or memberfunction in a programming language 
    137     """ 
    138     empty = False 
    139  
    140     def convert_docbook(self, converter): 
    141         return converter.target.methodname(self.content) 
    142  
    143     def convert_html(self, converter): 
    144         return converter.target.code(self.content, class_="method") 
    145  
    146 class property(base): 
    147     """ 
    148     The name of a property in a programming language 
    149     """ 
    150     empty = False 
    151  
    152     def convert_docbook(self, converter): 
    153         return converter.target.varname(self.content, role="property") 
    154  
    155     def convert_html(self, converter): 
    156         return converter.target.code(self.content, class_="property") 
    157  
    158 class class_(base): 
    159     """ 
    160     The name of a class, in the object-oriented programming sense 
    161     """ 
    162     xmlname = "class" 
    163     empty = False 
    164  
    165     def convert_docbook(self, converter): 
    166         return converter.target.classname(self.content) 
    167  
    168     def convert_html(self, converter): 
    169         return converter.target.code(self.content, class_="class") 
    170  
    171 class rep(base): 
    172     """ 
    173     Content that may or must be replaced by the user 
    174     """ 
    175     empty = False 
    176  
    177     def convert_docbook(self, converter): 
    178         return converter.target.replaceable(self.content) 
    179  
    180     def convert_html(self, converter): 
    181         return converter.target.var(self.content, class_="rep") 
    182  
    183 class markup(base): 
    184     """ 
    185     A string of formatting markup in text that is to be represented literally 
    186     """ 
    187     empty = False 
    188  
    189     def convert_docbook(self, converter): 
    190         return converter.target.markup(self.content) 
    191  
    192     def convert_html(self, converter): 
    193         return converter.target.code(self.content, class_="markup") 
    194  
    195 class arg(base): 
    196     """ 
    197     The name of a function or method argument. 
    198     """ 
    199     empty = False 
    200  
    201     def convert_docbook(self, converter): 
    202         return converter.target.parameter(self.content) 
    203  
    204     def convert_html(self, converter): 
    205         return converter.target.code(self.content, class_="arg") 
    206  
    207 class module(base): 
    208     """ 
    209     The name of Python module. 
    210     """ 
    211     empty = False 
    212  
    213     def convert_docbook(self, converter): 
    214         return converter.target.classname(self.content, role="module") 
    215  
    216     def convert_html(self, converter): 
    217         return converter.target.code(self.content, class_="module") 
    218  
    219 class parameter(base): 
    220     """ 
    221     A value or a symbolic reference to a value 
    222     """ 
    223     empty = False 
    224  
    225     def convert_docbook(self, converter): 
    226         return converter.target.parameter(self.content) 
    227  
    228     def convert_html(self, converter): 
    229         return converter.target.code(self.content, class_="parameter") 
    230  
    231 class filename(base): 
    232     """ 
    233     The name of a file 
    234     """ 
    235     empty = False 
    236  
    237     def convert_docbook(self, converter): 
    238         return converter.target.filename(self.content) 
    239  
    240     def convert_html(self, converter): 
    241         return converter.target.code(self.content, class_="filename") 
    242  
    243 class dirname(base): 
    244     """ 
    245     The name of directory 
    246     """ 
    247     empty = False 
    248  
    249     def convert_docbook(self, converter): 
    250         return converter.target.filename(self.content, class_="directory") 
    251  
    252     def convert_html(self, converter): 
    253         return converter.target.code(self.content, class_="dirname") 
    254  
    255 class username(base): 
    256     """ 
    257     The name of a user account 
    258     """ 
    259     empty = False 
    260  
    261     def convert_docbook(self, converter): 
    262         return converter.target.literal(self.content, role="username") 
    263  
    264     def convert_html(self, converter): 
    265         return converter.target.code(self.content, class_="username") 
    266  
    267 class app(base): 
    268     """ 
    269     The name of a software program 
    270     """ 
    271     empty = False 
    272     class Attrs(xsc.Element.Attrs): 
    273         class moreinfo(xsc.URLAttr): pass 
    274  
    275     def convert_docbook(self, converter): 
    276         return converter.target.application(self.content, moreinfo=self["moreinfo"]) 
    277  
    278     def convert_html(self, converter): 
    279         return converter.target.span(self.content, class_="app") 
    280  
    281 class title(base): 
    282     """ 
    283     The text of the title of a section of a document or of a formal block-level element 
    284     """ 
    285     empty = False 
    286  
    287     def convert_docbook(self, converter): 
    288         return converter.target.title(self.content.convert(converter)) 
    289  
    290     def convert_html(self, converter): 
    291         return self.content.convert(converter) 
    292  
    293 class section(block): 
    294     """ 
    295     A recursive section 
    296     """ 
    297     empty = False 
    298     class Attrs(xsc.Element.Attrs): 
    299         class role(xsc.TextAttr): pass 
    300         class id(xsc.IDAttr): pass 
    301  
    302     class Context(xsc.Element.Context): 
    303         def __init__(self): 
    304             xsc.Element.Context.__init__(self) 
    305             self.numbers = [0] 
    306  
    307     def convert(self, converter): 
    308         target = converter.target 
    309         if issubclass(target, docbook): 
    310             e = converter.target.section(self.content, role=self["role"], id=self["id"]) 
    311             return e.convert(converter) 
    312         elif issubclass(target, html): 
    313             context = converter[section] 
    314             context.numbers[-1] += 1 
    315             level = len(context.numbers) 
    316             context.numbers.append(0) # for numbering the subsections 
    317             ts = xsc.Frag() 
    318             cs = target.div(class_=("section level", level)) 
    319             if "role" in self.attrs: 
    320                 cs["class_"].append(" ", self.attrs["role"]) 
    321             for child in self: 
    322                 if isinstance(child, title): 
    323                     ts.append(child) 
    324                 else: 
    325                     cs.append(child) 
    326             e = xsc.Frag() 
    327             if self.attrs.has("id"): 
    328                 e.append(target.a(name=self["id"], id=self["id"])) 
    329             try: 
    330                 hclass = target.element("h%d" % level) 
    331             except LookupError: # ouch, we're nested to deep (a getter in a property in a class in a class) 
    332                 hclass = target.h6 
    333             for t in ts: 
    334                 h = hclass(t.content, class_=self["role"]) 
    335                 e.append(h) 
    336             e.append(cs) 
    337             # make sure to call the inner convert, because popping the number off of the stack 
    338             e = e.convert(converter) 
    339             del context.numbers[-1] 
    340             return e 
    341         else: 
    342             raise ValueError("unknown conversion target %r" % target) 
     546        e = xsc.Frag() 
     547        if "id" in self.attrs: 
     548            e.append(target.a(name=self["id"], id=self["id"])) 
     549        try: 
     550            hclass = target.element("h%d" % level) 
     551        except LookupError: # ouch, we're nested to deep (a getter in a property in a class in a class) 
     552            hclass = target.h6 
     553        for t in ts: 
     554            h = hclass(t.content, class_=self["role"]) 
     555            e.append(h) 
     556        e.append(cs) 
     557        # make sure to call the inner convert, before popping the number off of the stack 
     558        e = e.convert(converter) 
     559        del context.sections[-1] 
     560        return e 
     561 
     562    def convert_fo(self, converter): 
     563        context = converter[base] 
     564        context.sections[-1] += 1 
     565        context.sections.append(0) 
     566        ts = xsc.Frag() 
     567        cs = xsc.Frag() 
     568        props = [ 
     569            # size,   before, after 
     570            ("30pt", "30pt", "2pt"), 
     571            ("22pt", "20pt", "2pt"), 
     572            ("16pt", "15pt", "2pt"), 
     573            ("12pt", "15pt", "2pt") 
     574        ] 
     575        for child in self.content: 
     576            if isinstance(child, title): 
     577                ts.append(child.content) 
     578            else: 
     579                cs.append(child) 
     580        p = props[min(len(context.sections)-1, len(props)-1)] 
     581        isref = unicode(self["role"].convert(converter)) in ("class", "method", "property", "function", "module") 
     582 
     583        number = None 
     584        if isref: 
     585            context.indentcount += 1 
     586            text_indent = context.dedent() 
     587        else: 
     588            if len(context.sections)>2: 
     589                number = ( 
     590                    ".".join([str(x) for x in context.sections[1:-1]]), 
     591                    ". " 
     592                ) 
     593            text_indent = None 
     594 
     595        if len(context.sections)==2: 
     596            if context.sections[0]==1: 
     597                break_before = None 
     598            else: 
     599                break_before = "page" 
     600            tattrs = fo.block.Attrs( 
     601                font_family=context.hdfont, 
     602                color=context.llblue, 
     603                text_align="center", 
     604                font_size="36pt", 
     605                space_after="30pt", 
     606                break_before=break_before, 
     607                keep_with_next_within_page="always", 
     608            ) 
     609        else: 
     610            tattrs = fo.block.Attrs( 
     611                font_size=p[0], 
     612                space_before=p[1], 
     613                space_after=p[2], 
     614                text_align="left", 
     615                font_family=context.hdfont, 
     616                keep_with_next_within_page="always", 
     617                text_indent=text_indent 
     618            ) 
     619        e = fo.block( 
     620            fo.block(number, ts, tattrs), 
     621            cs, 
     622            start_indent=context.indent() 
     623        ) 
     624        e = e.convert(converter) 
     625        del context.sections[-1] 
     626        if isref: 
     627            context.indentcount -= 1 
     628        return e 
    343629 
    344630class par(block): 
     
    351637 
    352638    def convert_docbook(self, converter): 
    353         return converter.target.para(self.content, role=self["type"]) 
    354  
    355     def convert_html(self, converter): 
    356         return converter.target.p(self.content, class_=self["type"]) 
     639        e = converter.target.para(self.content, role=self["type"]) 
     640        return e.convert(converter) 
     641 
     642    def convert_html(self, converter): 
     643        e = converter.target.p(self.content, class_=self["type"]) 
     644        return e.convert(converter) 
     645 
     646    def convert_fo(self, converter): 
     647        e = fo.block( 
     648            self.content, 
     649            converter[base].vspaceattrs, 
     650            line_height="130%" 
     651        ) 
     652        return e.convert(converter) 
    357653 
    358654class list(block): 
     
    363659    """ 
    364660    register = False 
    365     class Context(block.Context): 
    366         def __init__(self): 
    367             self._lists = [] 
    368         def get(self): 
    369             return self._lists[-1] 
    370         def push(self, type): 
    371             self._lists.append(type) 
    372         def pop(self): 
    373             return self._lists.pop() 
    374661 
    375662class ulist(list): 
     
    379666    empty = False 
    380667 
    381     def convert(self, converter): 
    382         context = converter[list] 
    383         context.push(ulist) 
    384         target = converter.target 
    385         if issubclass(target, docbook): 
    386             node = converter.target.itemizedlist(self.content) 
    387         elif issubclass(target, html): 
    388             node = converter.target.ul(self.content) 
    389         else: 
    390             raise ValueError("unknown conversion target %r" % target) 
    391         return node.convert(converter) 
    392         context.pop() 
    393         return node 
     668    def convert_docbook(self, converter): 
     669        e = converter.target.itemizedlist(self.content.convert(converter)) 
     670        return e.convert(converter) 
     671 
     672    def convert_html(self, converter): 
     673        context = converter[base] 
     674        context.lists.append(["ulist", 0]) 
     675        e = converter.target.ul(self.content.convert(converter)) 
     676        del context.lists[-1] 
     677        return e 
     678 
     679    def convert_fo(self, converter): 
     680        context = converter[base] 
     681        context.lists.append(["ulist", 0]) 
     682        e = converter.target.list_block(self.content, line_height="130%") 
     683        e = e.convert(converter) 
     684        del context.lists[-1] 
     685        return e 
    394686 
    395687class olist(list): 
     
    399691    empty = False 
    400692 
    401     def convert(self, converter): 
    402         context = converter[list] 
    403         context.push(olist) 
    404         target = converter.target 
    405         if issubclass(target, docbook): 
    406             node = converter.target.orderedlist(self.content) 
    407         elif issubclass(target, html): 
    408             node = converter.target.ol(self.content) 
    409         else: 
    410             raise ValueError("unknown conversion target %r" % target) 
    411         return node.convert(converter) 
    412         context.pop() 
    413         return node 
     693    def convert_docbook(self, converter): 
     694        e = converter.target.orderedlist(self.content.convert(converter)) 
     695        return e.convert(converter) 
     696 
     697    def convert_html(self, converter): 
     698        context = converter[base] 
     699        context.lists.append(["olist", 0]) 
     700        e = converter.target.ol(self.content.convert(converter)) 
     701        del context.lists[-1] 
     702        return e 
     703 
     704    def convert_fo(self, converter): 
     705        context = converter[base] 
     706        context.lists.append(["olist", 0]) 
     707        e = converter.target.list_block(self.content, line_height="130%") 
     708        e = e.convert(converter) 
     709        del context.lists[-1] 
     710        return e 
    414711 
    415712class dlist(list): 
     
    419716    empty = False 
    420717 
    421     def convert(self, converter): 
    422         context = converter[list] 
    423         context.push(dlist) 
    424         target = converter.target 
    425         if issubclass(target, docbook): 
    426             node = converter.target.variablelist() 
    427             collect = converter.target.varlistentry() 
    428             for child in self.content: 
    429                 collect.append(child) 
    430                 if isinstance(child, item): 
    431                     node.append(collect) 
    432                     collect = converter.target.varlistentry() 
    433             if collect: 
    434                 node.append(collect) 
    435         elif issubclass(target, html): 
    436             node = converter.target.dl(self.content) 
    437         else: 
    438             raise ValueError("unknown conversion target %r" % target) 
    439         return node.convert(converter) 
    440         context.pop() 
    441         return node 
     718    def convert_docbook(self, converter): 
     719        e = converter.target.variablelist() 
     720        collect = converter.target.varlistentry() 
     721        for child in self.content: 
     722            collect.append(child) 
     723            if isinstance(child, item): 
     724                e.append(collect) 
     725                collect = converter.target.varlistentry() 
     726        if collect: 
     727            e.append(collect) 
     728        return e.convert(converter) 
     729 
     730    def convert_html(self, converter): 
     731        context = converter[base] 
     732        context.lists.append(["dlist", 0]) 
     733        e = converter.target.dl(self.content.convert(converter)) 
     734        del context.lists[-1] 
     735        return e 
     736 
     737    def convert_fo(self, converter): 
     738        context = converter[base] 
     739        context.lists.append(["dlist", 0]) 
     740        e = self.content.convert(converter) 
     741        del context.lists[-1] 
     742        return e 
    442743 
    443744class term(base): 
     
    448749 
    449750    def convert_docbook(self, converter): 
    450         return converter.target.term(self.content) 
    451  
    452     def convert_html(self, converter): 
    453         return converter.target.dt(self.content) 
     751        e = converter.target.term(self.content) 
     752        return e.convert(converter) 
     753 
     754    def convert_html(self, converter): 
     755        e = converter.target.dt(self.content) 
     756        return e.convert(converter) 
     757 
     758    def convert_fo(self, converter): 
     759        e = converter.target.block( 
     760            self.content, 
     761            font_style="italic" 
     762        ) 
     763        return e.convert(converter) 
    454764 
    455765class item(base): 
     
    464774        else: 
    465775            content = converter.target.para(self.content) 
    466         return converter.target.listitem(content) 
    467  
    468     def convert_html(self, converter): 
    469         context = converter[list] 
    470         if context.get() is dlist: 
    471             return converter.target.dd(self.content) 
    472         else: 
    473             return converter.target.li(self.content) 
    474  
    475 class self(base): 
     776        e = converter.target.listitem(content) 
     777        return e.convert(converter) 
     778 
     779    def convert_html(self, converter): 
     780        context = converter[base] 
     781        if context.lists[-1][0] == "dlist": 
     782            e = converter.target.dd(self.content) 
     783        else: 
     784            e = converter.target.li(self.content) 
     785        return e.convert(converter) 
     786 
     787    def convert_fo(self, converter): 
     788        target = converter.target 
     789        context = converter[base] 
     790        context.lists[-1][1] += 1 
     791        type = context.lists[-1][0] 
     792        if type=="ulist": 
     793            label = u"\u2022" 
     794        elif type=="olist": 
     795            label = "%d." % context.lists[-1][1] 
     796        context.indentcount += 1 
     797        if self.content.find(xsc.FindType(block)): 
     798            content = self.content 
     799        else: 
     800            content = self.xmlns.par(self.content) 
     801        if type=="dlist": 
     802            e = target.block( 
     803                content, 
     804                start_indent=context.indent() 
     805            ) 
     806        else: 
     807            e = target.list_item( 
     808                target.list_item_label( 
     809                    target.block(label), 
     810                    start_indent=context.labelindent() 
     811                ), 
     812                target.list_item_body( 
     813                    content, 
     814                    start_indent=context.indent() 
     815                ) 
     816            ) 
     817        context.indentcount -= 1 
     818        return e.convert(converter) 
     819 
     820class self(code): 
    476821    """ 
    477822    <par>use this class when referring to the object for which a method has been 
     
    486831 
    487832    def convert_docbook(self, converter): 
    488         return converter.target.varname("self") 
    489  
    490     def convert_html(self, converter): 
    491         return converter.target.code("self", class_="self") 
     833        e = converter.target.varname("self") 
     834        return e.convert(converter) 
     835 
     836    def convert_html(self, converter): 
     837        e = converter.target.code("self", class_="self") 
     838        return e.convert(converter) 
     839 
     840    def convert_fo(self, converter): 
     841        e = converter.target.inline("self", converter[base].codeattrs) 
     842        return e.convert(converter) 
    492843 
    493844    def __unicode__(self): 
    494845        return u"self" 
     846 
     847self_ = self 
    495848 
    496849class cls(base): 
     
    507860 
    508861    def convert_docbook(self, converter): 
    509         return converter.target.varname("cls") 
    510  
    511     def convert_html(self, converter): 
    512         return converter.target.code("cls", class_="cls") 
     862        e = converter.target.varname("cls") 
     863        return e.convert(converter) 
     864 
     865    def convert_html(self, converter): 
     866        e = converter.target.code("cls", class_="cls") 
     867        return e.convert(converter) 
     868 
     869    def convert_fo(self, converter): 
     870        e = converter.target.inline("cls", converter[base].codeattrs) 
     871        return e.convert(converter) 
    513872 
    514873    def __unicode__(self): 
     
    524883 
    525884    def convert_docbook(self, converter): 
    526         return converter.target.link(self.content, linkend=self["href"]) 
    527  
    528     def convert_html(self, converter): 
    529         return converter.target.a(self.content, href=self["href"]) 
     885        e = converter.target.link(self.content, linkend=self["href"]) 
     886        return e.convert(converter) 
     887 
     888    def convert_html(self, converter): 
     889        e = converter.target.a(self.content, href=self["href"]) 
     890        return e.convert(converter) 
     891 
     892    def convert_fo(self, converter): 
     893        if "href" in self.attrs: 
     894            e = converter.target.basic_link( 
     895                self.content, 
     896                converter[base].linkattrs, 
     897                external_destination=self["href"] 
     898            ) 
     899        else: 
     900            e = self.content 
     901        return e.convert(converter) 
    530902 
    531903class xref(xsc.Element): 
     
    538910 
    539911    def convert_docbook(self, converter): 
    540         return converter.target.link(self.content, linkend=self["href"]) 
    541  
    542     def convert_html(self, converter): 
    543         return converter.target.a(self.content, href=("#", self["ref"])) 
     912        e = converter.target.link(self.content, linkend=self["ref"]) 
     913        return e.convert(converter) 
     914 
     915    def convert_html(self, converter): 
     916        e = converter.target.a(self.content, href=("#", self["ref"])) 
     917        return e.convert(convertert) 
     918 
     919    def convert_fo(self, converter): 
     920        if "href" in self.attrs: 
     921            e = converter.target.basic_link( 
     922                self.content, 
     923                converter[base].linkattrs, 
     924                internal_destination=self["ref"] 
     925            ) 
     926        else: 
     927            e = self.content 
     928        return e.convert(converter) 
    544929 
    545930class email(base): 
     
    550935 
    551936    def convert_docbook(self, converter): 
    552         return converter.target.email(self.content) 
    553  
    554     def convert_html(self, converter): 
    555         return converter.target.a(self.content, href=("mailto:", self.content)) 
     937        e = converter.target.email(self.content) 
     938        return e.convert(converter) 
     939 
     940    def convert_html(self, converter): 
     941        e = converter.target.a(self.content, href=("mailto:", self.content)) 
     942        return e.convert(converter) 
     943 
     944    def convert_fo(self, converter): 
     945        e = converter.target.basic_link( 
     946            self.content, 
     947            converter[base].linkattrs, 
     948            external_destination=("mailto:", self.content) 
     949        ) 
     950        return e.convert(converter) 
    556951 
    557952class em(base): 
     
    562957 
    563958    def convert_docbook(self, converter): 
    564         return converter.target.emphasis(self.content) 
    565  
    566     def convert_html(self, converter): 
    567         return converter.target.em(self.content) 
     959        e = converter.target.emphasis(self.content) 
     960        return e.convert(converter) 
     961 
     962    def convert_html(self, converter): 
     963        e = converter.target.em(self.content) 
     964        return e.convert(converter) 
     965 
     966    def convert_fo(self, converter): 
     967        e = converter.target.inline( 
     968            self.content, 
     969            converter[base].emattrs 
     970        ) 
     971        return e.convert(converter) 
    568972 
    569973class pyref(base): 
     
    584988    def convert(self, converter): 
    585989        target = converter.target 
     990        if issubclass(target, xmlns): # our own namespace 
     991            return self.convert_doc(converter) 
    586992        if self.attrs.has("function"): 
    587993            function = unicode(self["function"].convert(converter)) 
     
    9111317explain = classmethod(explain) 
    9121318 
     1319class DOC2FO(object): 
     1320    def __init__(self): 
     1321        self.llblue = "#006499" 
     1322        self.llgreen = "#9fc94d" 
     1323 
     1324        self.ttfont = "CourierNew, monospace" 
     1325        #self.ttfont = "monospace" 
     1326        self.hdfont = "ArialNarrow, Arial, sans-serif" 
     1327        self.hdcolor = "#000" 
     1328        #self.hdfont = "sans-serif" 
     1329        #self.hdfont = "Microgramma" 
     1330        self.font = "Times New Roman, serif" 
     1331        self.font = "Microgramma" 
     1332        self.font = "PalatinoLinotype" 
     1333 
     1334        self.linkcolor = "blue" 
     1335 
     1336        self.indentcount = 0 
     1337 
     1338        self.vspaceattrs = { 
     1339            "space_before": "0pt", 
     1340            "space_after_minimum": "4pt", 
     1341            "space_after_optimum": "6pt", 
     1342            "space_after_maximum": "12pt", 
     1343            "space_after_conditionality": "discard", 
     1344        } 
     1345 
     1346        self.lists = [] 
     1347        self.sections = [0] 
     1348 
     1349    def dedent(self): 
     1350        return "-0.7cm" 
     1351 
     1352    def indent(self): 
     1353        return "%.1fcm" % (0.7*self.indentcount) 
     1354 
     1355    def labelindent(self): 
     1356        return "%.1fcm" % (0.7*self.indentcount-0.4) 
     1357 
     1358    def map_pyref(self, node, converter): 
     1359        node = node.content.mapped(self.mapped, converter) 
     1360        return node 
     1361 
     1362    def mapped(self, node, converter): 
     1363        if isinstance(node, section): 
     1364            node = self.map_section(node, converter) 
     1365        elif isinstance(node, par): 
     1366            node = self.map_par(node, converter) 
     1367        elif isinstance(node, ulist): 
     1368            node = self.map_ulist(node, converter) 
     1369        elif isinstance(node, olist): 
     1370            node = self.map_olist(node, converter) 
     1371        elif isinstance(node, dlist): 
     1372            node = self.map_dlist(node, converter) 
     1373        elif isinstance(node, term): 
     1374            node = self.map_term(node, converter) 
     1375        elif isinstance(node, item): 
     1376            node = self.map_item(node, converter) 
     1377        elif isinstance(node, example): 
     1378            node = self.map_example(node, converter) 
     1379        elif isinstance(node, prog): 
     1380            node = self.map_prog(node, converter) 
     1381        elif isinstance(node, specials.z): 
     1382            node = self.map_z(node, converter) 
     1383        elif isinstance(node, abbr): 
     1384            node = self.map_abbr(node, converter) 
     1385        elif isinstance(node, em): 
     1386            node = self.map_em(node, converter) 
     1387        elif isinstance(node, (module, class_, method, lit, function, markup, arg, option, property)): 
     1388            node = self.map_code(node, converter) 
     1389        elif isinstance(node, dirname): 
     1390            node = self.map_dirname(node, converter) 
     1391        elif isinstance(node, filename): 
     1392            node = self.map_filename(node, converter) 
     1393        elif isinstance(node, rep): 
     1394            node = self.map_ref(node, converter) 
     1395        elif isinstance(node, self_): 
     1396            node = self.map_self(node, converter) 
     1397        elif isinstance(node, cls): 
     1398            node = self.map_cls(node, converter) 
     1399        elif isinstance(node, app): 
     1400            return self.map_app(node, converter) 
     1401        elif isinstance(node, link): 
     1402            return self.map_link(node, converter) 
     1403        elif isinstance(node, email): 
     1404            return self.map_email(node, converter) 
     1405        elif isinstance(node, pyref): 
     1406            return self.map_pyref(node, converter) 
     1407        elif isinstance(node, xsc.Element): 
     1408            from ll.xist import presenters 
     1409            print "unconvertable node %r at %s" % (node, node.startloc) 
     1410            print node.repr(presenters.CodePresenter()) 
     1411            node = self.mapped(node.content, converter) 
     1412        return node 
     1413 
     1414class fodoc(xsc.Element): 
     1415    empty = False 
     1416 
     1417    def convert(self, converter): 
     1418        context = converter[base] 
     1419        e = self.content 
     1420        converter.push(target=xmlns) 
     1421        e = e.convert(converter) 
     1422        converter.pop() 
     1423        converter.push(target=fo) 
     1424        e = e.convert(converter) 
     1425        converter.pop() 
     1426 
     1427        e = xsc.Frag( 
     1428            xml.XML10(), "\n", 
     1429            fo.root( 
     1430                fo.layout_master_set( 
     1431                    fo.simple_page_master( 
     1432                        fo.region_body( 
     1433                            region_name="xsl-region-body", 
     1434                            margin_bottom="3cm" 
     1435                        ), 
     1436                        fo.region_after( 
     1437                            region_name="xsl-region-after", 
     1438                            extent="2cm" 
     1439                        ), 
     1440                        master_name="default", 
     1441                        page_height="29.7cm", 
     1442                        page_width="21cm", 
     1443                        margin_top="1cm", 
     1444                        margin_bottom="1cm", 
     1445                        margin_left="2.5cm", 
     1446                        margin_right="1cm" 
     1447                    ) 
     1448                ), 
     1449                fo.page_sequence( 
     1450                    fo.static_content( 
     1451                        fo.block( 
     1452                            fo.page_number(), 
     1453                            border_before_width="0.1pt", 
     1454                            border_before_color="#000", 
     1455                            border_before_style="solid", 
     1456                            padding_before="4pt", 
     1457                            text_align="center" 
     1458                        ), 
     1459                        flow_name="xsl-region-after" 
     1460                    ), 
     1461                    fo.flow( 
     1462                        e, 
     1463                        flow_name="xsl-region-body" 
     1464                    ), 
     1465                    master_reference="default" 
     1466                ), 
     1467                font_family=context.font, 
     1468                font_size="10pt", 
     1469                text_align="justify", 
     1470                line_height="normal", 
     1471                language="en", 
     1472                orphans=2, 
     1473                widows=3 
     1474            ) 
     1475        ) 
     1476        return e 
     1477 
    9131478class xmlns(xsc.Namespace): 
    9141479    xmlname = "doc"