| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728 |
- <html xmlns="http://www.w3.org/1999/xhtml">
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
- <link rel="shortcut icon" href="/favicon.ico" type="image/x-icon">
- <head>
- <title>
-
- Defs and Blocks
- —
- Mako 0.8.1 Documentation
- </title>
- <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
- <link rel="stylesheet" href="_static/docs.css" type="text/css" />
- <script type="text/javascript">
- var DOCUMENTATION_OPTIONS = {
- URL_ROOT: '#',
- VERSION: '0.8.1',
- COLLAPSE_MODINDEX: false,
- FILE_SUFFIX: '.html'
- };
- </script>
- <script type="text/javascript" src="_static/jquery.js"></script>
- <script type="text/javascript" src="_static/underscore.js"></script>
- <script type="text/javascript" src="_static/doctools.js"></script>
- <link rel="index" title="Index" href="genindex.html" />
- <link rel="search" title="Search" href="search.html" />
- <link rel="top" title="Mako 0.8.1 Documentation" href="index.html" />
- <link rel="next" title="The Mako Runtime Environment" href="runtime.html" />
- <link rel="prev" title="Syntax" href="syntax.html" />
- <link rel="stylesheet" href="_static/site.css"></link>
- </head>
- <body>
- <div id="wrap">
- <div class="rightbar">
- <div class="slogan">
- Hyperfast and lightweight templating for the Python platform.
- </div>
- </div>
- <a href="http://www.makotemplates.org/"><img src="_static/makoLogo.png" /></a>
- <hr/>
-
- <div id="docs-container">
- <div id="docs-header">
- <h1>Mako 0.8.1 Documentation</h1>
- <div id="docs-search">
- Search:
- <form class="search" action="search.html" method="get">
- <input type="text" name="q" size="18" /> <input type="submit" value="Search" />
- <input type="hidden" name="check_keywords" value="yes" />
- <input type="hidden" name="area" value="default" />
- </form>
- </div>
- <div id="docs-version-header">
- Release: <span class="version-num">0.8.1</span>
- </div>
- </div>
- <div id="docs-top-navigation">
- <div id="docs-top-page-control" class="docs-navigation-links">
- <ul>
- <li>Prev:
- <a href="syntax.html" title="previous chapter">Syntax</a>
- </li>
- <li>Next:
- <a href="runtime.html" title="next chapter">The Mako Runtime Environment</a>
- </li>
- <li>
- <a href="index.html">Table of Contents</a> |
- <a href="genindex.html">Index</a>
- | <a href="_sources/defs.txt">view source
- </li>
- </ul>
- </div>
- <div id="docs-navigation-banner">
- <a href="index.html">Mako 0.8.1 Documentation</a>
- »
- Defs and Blocks
-
- <h2>
-
- Defs and Blocks
-
- </h2>
- </div>
- </div>
- <div id="docs-body-container">
- <div id="docs-sidebar">
- <h3><a href="index.html">Table of Contents</a></h3>
- <ul>
- <li><a class="reference internal" href="#">Defs and Blocks</a><ul>
- <li><a class="reference internal" href="#using-defs">Using Defs</a><ul>
- <li><a class="reference internal" href="#calling-defs-from-other-files">Calling Defs from Other Files</a></li>
- <li><a class="reference internal" href="#calling-defs-programmatically">Calling Defs Programmatically</a></li>
- <li><a class="reference internal" href="#defs-within-defs">Defs within Defs</a></li>
- <li><a class="reference internal" href="#calling-a-def-with-embedded-content-and-or-other-defs">Calling a Def with Embedded Content and/or Other Defs</a></li>
- </ul>
- </li>
- <li><a class="reference internal" href="#using-blocks">Using Blocks</a><ul>
- <li><a class="reference internal" href="#using-named-blocks">Using Named Blocks</a></li>
- <li><a class="reference internal" href="#using-page-arguments-in-named-blocks">Using Page Arguments in Named Blocks</a></li>
- </ul>
- </li>
- </ul>
- </li>
- </ul>
- <h4>Previous Topic</h4>
- <p>
- <a href="syntax.html" title="previous chapter">Syntax</a>
- </p>
- <h4>Next Topic</h4>
- <p>
- <a href="runtime.html" title="next chapter">The Mako Runtime Environment</a>
- </p>
- <h4>Quick Search</h4>
- <p>
- <form class="search" action="search.html" method="get">
- <input type="text" name="q" size="18" /> <input type="submit" value="Search" />
- <input type="hidden" name="check_keywords" value="yes" />
- <input type="hidden" name="area" value="default" />
- </form>
- </p>
- </div>
- <div id="docs-body" class="withsidebar" >
-
- <div class="section" id="defs-and-blocks">
- <span id="defs-toplevel"></span><h1>Defs and Blocks<a class="headerlink" href="#defs-and-blocks" title="Permalink to this headline">¶</a></h1>
- <p><tt class="docutils literal"><span class="pre"><%def></span></tt> and <tt class="docutils literal"><span class="pre"><%block></span></tt> are two tags that both demarcate any block of text
- and/or code. They both exist within generated Python as a callable function,
- i.e., a Python <tt class="docutils literal"><span class="pre">def</span></tt>. They differ in their scope and calling semantics.
- Whereas <tt class="docutils literal"><span class="pre"><%def></span></tt> provides a construct that is very much like a named Python
- <tt class="docutils literal"><span class="pre">def</span></tt>, the <tt class="docutils literal"><span class="pre"><%block></span></tt> is more layout oriented.</p>
- <div class="section" id="using-defs">
- <h2>Using Defs<a class="headerlink" href="#using-defs" title="Permalink to this headline">¶</a></h2>
- <p>The <tt class="docutils literal"><span class="pre"><%def></span></tt> tag requires a <tt class="docutils literal"><span class="pre">name</span></tt> attribute, where the <tt class="docutils literal"><span class="pre">name</span></tt> references
- a Python function signature:</p>
- <div class="highlight-mako"><div class="highlight"><pre><span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"hello()"</span><span class="cp">></span><span class="x"></span>
- <span class="x"> hello world</span>
- <span class="cp"></%</span><span class="nb">def</span><span class="cp">></span><span class="x"></span>
- </pre></div>
- </div>
- <p>To invoke the <tt class="docutils literal"><span class="pre"><%def></span></tt>, it is normally called as an expression:</p>
- <div class="highlight-mako"><div class="highlight"><pre><span class="x">the def: </span><span class="cp">${</span><span class="n">hello</span><span class="p">()</span><span class="cp">}</span><span class="x"></span>
- </pre></div>
- </div>
- <p>If the <tt class="docutils literal"><span class="pre"><%def></span></tt> is not nested inside of another <tt class="docutils literal"><span class="pre"><%def></span></tt>,
- it’s known as a <strong>top level def</strong> and can be accessed anywhere in
- the template, including above where it was defined.</p>
- <p>All defs, top level or not, have access to the current
- contextual namespace in exactly the same way their containing
- template does. Suppose the template below is executed with the
- variables <tt class="docutils literal"><span class="pre">username</span></tt> and <tt class="docutils literal"><span class="pre">accountdata</span></tt> inside the context:</p>
- <div class="highlight-mako"><div class="highlight"><pre><span class="x">Hello there </span><span class="cp">${</span><span class="n">username</span><span class="cp">}</span><span class="x">, how are ya. Lets see what your account says:</span>
- <span class="cp">${</span><span class="n">account</span><span class="p">()</span><span class="cp">}</span><span class="x"></span>
- <span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"account()"</span><span class="cp">></span><span class="x"></span>
- <span class="x"> Account for </span><span class="cp">${</span><span class="n">username</span><span class="cp">}</span><span class="x">:<br/></span>
- <span class="cp">%</span> <span class="k">for</span> <span class="n">row</span> <span class="ow">in</span> <span class="n">accountdata</span><span class="p">:</span><span class="x"></span>
- <span class="x"> Value: </span><span class="cp">${</span><span class="n">row</span><span class="cp">}</span><span class="x"><br/></span>
- <span class="cp">%</span><span class="k"> endfor</span><span class="x"></span>
- <span class="cp"></%</span><span class="nb">def</span><span class="cp">></span><span class="x"></span>
- </pre></div>
- </div>
- <p>The <tt class="docutils literal"><span class="pre">username</span></tt> and <tt class="docutils literal"><span class="pre">accountdata</span></tt> variables are present
- within the main template body as well as the body of the
- <tt class="docutils literal"><span class="pre">account()</span></tt> def.</p>
- <p>Since defs are just Python functions, you can define and pass
- arguments to them as well:</p>
- <div class="highlight-mako"><div class="highlight"><pre><span class="cp">${</span><span class="n">account</span><span class="p">(</span><span class="n">accountname</span><span class="o">=</span><span class="s">'john'</span><span class="p">)</span><span class="cp">}</span><span class="x"></span>
- <span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"account(accountname, type='regular')"</span><span class="cp">></span><span class="x"></span>
- <span class="x"> account name: </span><span class="cp">${</span><span class="n">accountname</span><span class="cp">}</span><span class="x">, type: </span><span class="cp">${</span><span class="nb">type</span><span class="cp">}</span><span class="x"></span>
- <span class="cp"></%</span><span class="nb">def</span><span class="cp">></span><span class="x"></span>
- </pre></div>
- </div>
- <p>When you declare an argument signature for your def, they are
- required to follow normal Python conventions (i.e., all
- arguments are required except keyword arguments with a default
- value). This is in contrast to using context-level variables,
- which evaluate to <tt class="docutils literal"><span class="pre">UNDEFINED</span></tt> if you reference a name that
- does not exist.</p>
- <div class="section" id="calling-defs-from-other-files">
- <h3>Calling Defs from Other Files<a class="headerlink" href="#calling-defs-from-other-files" title="Permalink to this headline">¶</a></h3>
- <p>Top level <tt class="docutils literal"><span class="pre"><%def></span></tt>s are <strong>exported</strong> by your template’s
- module, and can be called from the outside; including from other
- templates, as well as normal Python code. Calling a <tt class="docutils literal"><span class="pre"><%def></span></tt>
- from another template is something like using an <tt class="docutils literal"><span class="pre"><%include></span></tt>
- – except you are calling a specific function within the
- template, not the whole template.</p>
- <p>The remote <tt class="docutils literal"><span class="pre"><%def></span></tt> call is also a little bit like calling
- functions from other modules in Python. There is an “import”
- step to pull the names from another template into your own
- template; then the function or functions are available.</p>
- <p>To import another template, use the <tt class="docutils literal"><span class="pre"><%namespace></span></tt> tag:</p>
- <div class="highlight-mako"><div class="highlight"><pre><span class="cp"><%</span><span class="nb">namespace</span> <span class="na">name=</span><span class="s">"mystuff"</span> <span class="na">file=</span><span class="s">"mystuff.html"</span><span class="cp">/></span><span class="x"></span>
- </pre></div>
- </div>
- <p>The above tag adds a local variable <tt class="docutils literal"><span class="pre">mystuff</span></tt> to the current
- scope.</p>
- <p>Then, just call the defs off of <tt class="docutils literal"><span class="pre">mystuff</span></tt>:</p>
- <div class="highlight-mako"><div class="highlight"><pre><span class="cp">${</span><span class="n">mystuff</span><span class="o">.</span><span class="n">somedef</span><span class="p">(</span><span class="n">x</span><span class="o">=</span><span class="mi">5</span><span class="p">,</span><span class="n">y</span><span class="o">=</span><span class="mi">7</span><span class="p">)</span><span class="cp">}</span><span class="x"></span>
- </pre></div>
- </div>
- <p>The <tt class="docutils literal"><span class="pre"><%namespace></span></tt> tag also supports some of the other
- semantics of Python’s <tt class="docutils literal"><span class="pre">import</span></tt> statement, including pulling
- names into the local variable space, or using <tt class="docutils literal"><span class="pre">*</span></tt> to represent
- all names, using the <tt class="docutils literal"><span class="pre">import</span></tt> attribute:</p>
- <div class="highlight-mako"><div class="highlight"><pre><span class="cp"><%</span><span class="nb">namespace</span> <span class="na">file=</span><span class="s">"mystuff.html"</span> <span class="na">import=</span><span class="s">"foo, bar"</span><span class="cp">/></span><span class="x"></span>
- </pre></div>
- </div>
- <p>This is just a quick intro to the concept of a <strong>namespace</strong>,
- which is a central Mako concept that has its own chapter in
- these docs. For more detail and examples, see
- <a class="reference internal" href="namespaces.html"><em>Namespaces</em></a>.</p>
- </div>
- <div class="section" id="calling-defs-programmatically">
- <h3>Calling Defs Programmatically<a class="headerlink" href="#calling-defs-programmatically" title="Permalink to this headline">¶</a></h3>
- <p>You can call defs programmatically from any <a class="reference internal" href="usage.html#mako.template.Template" title="mako.template.Template"><tt class="xref py py-class docutils literal"><span class="pre">Template</span></tt></a> object
- using the <a class="reference internal" href="usage.html#mako.template.Template.get_def" title="mako.template.Template.get_def"><tt class="xref py py-meth docutils literal"><span class="pre">get_def()</span></tt></a> method, which returns a <a class="reference internal" href="usage.html#mako.template.DefTemplate" title="mako.template.DefTemplate"><tt class="xref py py-class docutils literal"><span class="pre">DefTemplate</span></tt></a>
- object. This is a <a class="reference internal" href="usage.html#mako.template.Template" title="mako.template.Template"><tt class="xref py py-class docutils literal"><span class="pre">Template</span></tt></a> subclass which the parent
- <a class="reference internal" href="usage.html#mako.template.Template" title="mako.template.Template"><tt class="xref py py-class docutils literal"><span class="pre">Template</span></tt></a> creates, and is usable like any other template:</p>
- <div class="highlight-python"><div class="highlight"><pre><span class="kn">from</span> <span class="nn">mako.template</span> <span class="kn">import</span> <span class="n">Template</span>
- <span class="n">template</span> <span class="o">=</span> <span class="n">Template</span><span class="p">(</span><span class="s">"""</span>
- <span class="s"> <</span><span class="si">%d</span><span class="s">ef name="hi(name)"></span>
- <span class="s"> hi ${name}!</span>
- <span class="s"> </</span><span class="si">%d</span><span class="s">ef></span>
- <span class="s"> <</span><span class="si">%d</span><span class="s">ef name="bye(name)"></span>
- <span class="s"> bye ${name}!</span>
- <span class="s"> </</span><span class="si">%d</span><span class="s">ef></span>
- <span class="s">"""</span><span class="p">)</span>
- <span class="k">print</span> <span class="n">template</span><span class="o">.</span><span class="n">get_def</span><span class="p">(</span><span class="s">"hi"</span><span class="p">)</span><span class="o">.</span><span class="n">render</span><span class="p">(</span><span class="n">name</span><span class="o">=</span><span class="s">"ed"</span><span class="p">)</span>
- <span class="k">print</span> <span class="n">template</span><span class="o">.</span><span class="n">get_def</span><span class="p">(</span><span class="s">"bye"</span><span class="p">)</span><span class="o">.</span><span class="n">render</span><span class="p">(</span><span class="n">name</span><span class="o">=</span><span class="s">"ed"</span><span class="p">)</span>
- </pre></div>
- </div>
- </div>
- <div class="section" id="defs-within-defs">
- <h3>Defs within Defs<a class="headerlink" href="#defs-within-defs" title="Permalink to this headline">¶</a></h3>
- <p>The def model follows regular Python rules for closures.
- Declaring <tt class="docutils literal"><span class="pre"><%def></span></tt> inside another <tt class="docutils literal"><span class="pre"><%def></span></tt> declares it
- within the parent’s <strong>enclosing scope</strong>:</p>
- <div class="highlight-mako"><div class="highlight"><pre><span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"mydef()"</span><span class="cp">></span><span class="x"></span>
- <span class="x"> </span><span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"subdef()"</span><span class="cp">></span><span class="x"></span>
- <span class="x"> a sub def</span>
- <span class="x"> </span><span class="cp"></%</span><span class="nb">def</span><span class="cp">></span><span class="x"></span>
- <span class="x"> i'm the def, and the subcomponent is </span><span class="cp">${</span><span class="n">subdef</span><span class="p">()</span><span class="cp">}</span><span class="x"></span>
- <span class="cp"></%</span><span class="nb">def</span><span class="cp">></span><span class="x"></span>
- </pre></div>
- </div>
- <p>Just like Python, names that exist outside the inner <tt class="docutils literal"><span class="pre"><%def></span></tt>
- exist inside it as well:</p>
- <div class="highlight-mako"><div class="highlight"><pre><span class="cp"><%</span>
- <span class="n">x</span> <span class="o">=</span> <span class="mi">12</span>
- <span class="cp">%></span><span class="x"></span>
- <span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"outer()"</span><span class="cp">></span><span class="x"></span>
- <span class="x"> </span><span class="cp"><%</span>
- <span class="n">y</span> <span class="o">=</span> <span class="mi">15</span>
- <span class="cp">%></span><span class="x"></span>
- <span class="x"> </span><span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"inner()"</span><span class="cp">></span><span class="x"></span>
- <span class="x"> inner, x is </span><span class="cp">${</span><span class="n">x</span><span class="cp">}</span><span class="x">, y is </span><span class="cp">${</span><span class="n">y</span><span class="cp">}</span><span class="x"></span>
- <span class="x"> </span><span class="cp"></%</span><span class="nb">def</span><span class="cp">></span><span class="x"></span>
- <span class="x"> outer, x is </span><span class="cp">${</span><span class="n">x</span><span class="cp">}</span><span class="x">, y is </span><span class="cp">${</span><span class="n">y</span><span class="cp">}</span><span class="x"></span>
- <span class="cp"></%</span><span class="nb">def</span><span class="cp">></span><span class="x"></span>
- </pre></div>
- </div>
- <p>Assigning to a name inside of a def declares that name as local
- to the scope of that def (again, like Python itself). This means
- the following code will raise an error:</p>
- <div class="highlight-mako"><div class="highlight"><pre><span class="cp"><%</span>
- <span class="n">x</span> <span class="o">=</span> <span class="mi">10</span>
- <span class="cp">%></span><span class="x"></span>
- <span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"somedef()"</span><span class="cp">></span>
- <span class="cp">## error !</span><span class="x"></span>
- <span class="x"> somedef, x is </span><span class="cp">${</span><span class="n">x</span><span class="cp">}</span><span class="x"></span>
- <span class="x"> </span><span class="cp"><%</span>
- <span class="n">x</span> <span class="o">=</span> <span class="mi">27</span>
- <span class="cp">%></span><span class="x"></span>
- <span class="cp"></%</span><span class="nb">def</span><span class="cp">></span><span class="x"></span>
- </pre></div>
- </div>
- <p>...because the assignment to <tt class="docutils literal"><span class="pre">x</span></tt> declares <tt class="docutils literal"><span class="pre">x</span></tt> as local to the
- scope of <tt class="docutils literal"><span class="pre">somedef</span></tt>, rendering the “outer” version unreachable
- in the expression that tries to render it.</p>
- </div>
- <div class="section" id="calling-a-def-with-embedded-content-and-or-other-defs">
- <span id="defs-with-content"></span><h3>Calling a Def with Embedded Content and/or Other Defs<a class="headerlink" href="#calling-a-def-with-embedded-content-and-or-other-defs" title="Permalink to this headline">¶</a></h3>
- <p>A flip-side to def within def is a def call with content. This
- is where you call a def, and at the same time declare a block of
- content (or multiple blocks) that can be used by the def being
- called. The main point of such a call is to create custom,
- nestable tags, just like any other template language’s
- custom-tag creation system – where the external tag controls the
- execution of the nested tags and can communicate state to them.
- Only with Mako, you don’t have to use any external Python
- modules, you can define arbitrarily nestable tags right in your
- templates.</p>
- <p>To achieve this, the target def is invoked using the form
- <tt class="docutils literal"><span class="pre"><%namepacename:defname></span></tt> instead of the normal <tt class="docutils literal"><span class="pre">${}</span></tt>
- syntax. This syntax, introduced in Mako 0.2.3, is functionally
- equivalent to another tag known as <tt class="docutils literal"><span class="pre">%call</span></tt>, which takes the form
- <tt class="docutils literal"><span class="pre"><%call</span> <span class="pre">expr='namespacename.defname(args)'></span></tt>. While <tt class="docutils literal"><span class="pre">%call</span></tt>
- is available in all versions of Mako, the newer style is
- probably more familiar looking. The <tt class="docutils literal"><span class="pre">namespace</span></tt> portion of the
- call is the name of the <strong>namespace</strong> in which the def is
- defined – in the most simple cases, this can be <tt class="docutils literal"><span class="pre">local</span></tt> or
- <tt class="docutils literal"><span class="pre">self</span></tt> to reference the current template’s namespace (the
- difference between <tt class="docutils literal"><span class="pre">local</span></tt> and <tt class="docutils literal"><span class="pre">self</span></tt> is one of inheritance
- – see <a class="reference internal" href="namespaces.html#namespaces-builtin"><em>Built-in Namespaces</em></a> for details).</p>
- <p>When the target def is invoked, a variable <tt class="docutils literal"><span class="pre">caller</span></tt> is placed
- in its context which contains another namespace containing the
- body and other defs defined by the caller. The body itself is
- referenced by the method <tt class="docutils literal"><span class="pre">body()</span></tt>. Below, we build a <tt class="docutils literal"><span class="pre">%def</span></tt>
- that operates upon <tt class="docutils literal"><span class="pre">caller.body()</span></tt> to invoke the body of the
- custom tag:</p>
- <div class="highlight-mako"><div class="highlight"><pre><span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"buildtable()"</span><span class="cp">></span><span class="x"></span>
- <span class="x"> <table></span>
- <span class="x"> <tr><td></span>
- <span class="x"> </span><span class="cp">${</span><span class="n">caller</span><span class="o">.</span><span class="n">body</span><span class="p">()</span><span class="cp">}</span><span class="x"></span>
- <span class="x"> </td></tr></span>
- <span class="x"> </table></span>
- <span class="cp"></%</span><span class="nb">def</span><span class="cp">></span><span class="x"></span>
- <span class="cp"><%</span><span class="nb">self:buildtable</span><span class="cp">></span><span class="x"></span>
- <span class="x"> I am the table body.</span>
- <span class="cp"></%</span><span class="nb">self:buildtable</span><span class="cp">></span><span class="x"></span>
- </pre></div>
- </div>
- <p>This produces the output (whitespace formatted):</p>
- <div class="highlight-html"><div class="highlight"><pre><span class="nt"><table></span>
- <span class="nt"><tr><td></span>
- I am the table body.
- <span class="nt"></td></tr></span>
- <span class="nt"></table></span>
- </pre></div>
- </div>
- <p>Using the older <tt class="docutils literal"><span class="pre">%call</span></tt> syntax looks like:</p>
- <div class="highlight-mako"><div class="highlight"><pre><span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"buildtable()"</span><span class="cp">></span><span class="x"></span>
- <span class="x"> <table></span>
- <span class="x"> <tr><td></span>
- <span class="x"> </span><span class="cp">${</span><span class="n">caller</span><span class="o">.</span><span class="n">body</span><span class="p">()</span><span class="cp">}</span><span class="x"></span>
- <span class="x"> </td></tr></span>
- <span class="x"> </table></span>
- <span class="cp"></%</span><span class="nb">def</span><span class="cp">></span><span class="x"></span>
- <span class="cp"><%</span><span class="nb">call</span> <span class="na">expr=</span><span class="s">"buildtable()"</span><span class="cp">></span><span class="x"></span>
- <span class="x"> I am the table body.</span>
- <span class="cp"></%</span><span class="nb">call</span><span class="cp">></span><span class="x"></span>
- </pre></div>
- </div>
- <p>The <tt class="docutils literal"><span class="pre">body()</span></tt> can be executed multiple times or not at all.
- This means you can use def-call-with-content to build iterators,
- conditionals, etc:</p>
- <div class="highlight-mako"><div class="highlight"><pre><span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"lister(count)"</span><span class="cp">></span>
- <span class="cp">%</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">count</span><span class="p">):</span><span class="x"></span>
- <span class="x"> </span><span class="cp">${</span><span class="n">caller</span><span class="o">.</span><span class="n">body</span><span class="p">()</span><span class="cp">}</span>
- <span class="cp">%</span><span class="k"> endfor</span><span class="x"></span>
- <span class="cp"></%</span><span class="nb">def</span><span class="cp">></span><span class="x"></span>
- <span class="cp"><%</span><span class="nb">self:lister</span> <span class="na">count=</span><span class="s">"${3}"</span><span class="cp">></span><span class="x"></span>
- <span class="x"> hi</span>
- <span class="cp"></%</span><span class="nb">self:lister</span><span class="cp">></span><span class="x"></span>
- </pre></div>
- </div>
- <p>Produces:</p>
- <div class="highlight-html"><div class="highlight"><pre>hi
- hi
- hi
- </pre></div>
- </div>
- <p>Notice above we pass <tt class="docutils literal"><span class="pre">3</span></tt> as a Python expression, so that it
- remains as an integer.</p>
- <p>A custom “conditional” tag:</p>
- <div class="highlight-mako"><div class="highlight"><pre><span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"conditional(expression)"</span><span class="cp">></span>
- <span class="cp">%</span> <span class="k">if</span> <span class="n">expression</span><span class="p">:</span><span class="x"></span>
- <span class="x"> </span><span class="cp">${</span><span class="n">caller</span><span class="o">.</span><span class="n">body</span><span class="p">()</span><span class="cp">}</span>
- <span class="cp">%</span><span class="k"> endif</span><span class="x"></span>
- <span class="cp"></%</span><span class="nb">def</span><span class="cp">></span><span class="x"></span>
- <span class="cp"><%</span><span class="nb">self:conditional</span> <span class="na">expression=</span><span class="s">"${4==4}"</span><span class="cp">></span><span class="x"></span>
- <span class="x"> i'm the result</span>
- <span class="cp"></%</span><span class="nb">self:conditional</span><span class="cp">></span><span class="x"></span>
- </pre></div>
- </div>
- <p>Produces:</p>
- <div class="highlight-html"><div class="highlight"><pre>i'm the result
- </pre></div>
- </div>
- <p>But that’s not all. The <tt class="docutils literal"><span class="pre">body()</span></tt> function also can handle
- arguments, which will augment the local namespace of the body
- callable. The caller must define the arguments which it expects
- to receive from its target def using the <tt class="docutils literal"><span class="pre">args</span></tt> attribute,
- which is a comma-separated list of argument names. Below, our
- <tt class="docutils literal"><span class="pre"><%def></span></tt> calls the <tt class="docutils literal"><span class="pre">body()</span></tt> of its caller, passing in an
- element of data from its argument:</p>
- <div class="highlight-mako"><div class="highlight"><pre><span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"layoutdata(somedata)"</span><span class="cp">></span><span class="x"></span>
- <span class="x"> <table></span>
- <span class="cp">%</span> <span class="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="n">somedata</span><span class="p">:</span><span class="x"></span>
- <span class="x"> <tr></span>
- <span class="cp">%</span> <span class="k">for</span> <span class="n">col</span> <span class="ow">in</span> <span class="n">item</span><span class="p">:</span><span class="x"></span>
- <span class="x"> <td></span><span class="cp">${</span><span class="n">caller</span><span class="o">.</span><span class="n">body</span><span class="p">(</span><span class="n">col</span><span class="o">=</span><span class="n">col</span><span class="p">)</span><span class="cp">}</span><span class="x"></td></span>
- <span class="cp">%</span><span class="k"> endfor</span><span class="x"></span>
- <span class="x"> </tr></span>
- <span class="cp">%</span><span class="k"> endfor</span><span class="x"></span>
- <span class="x"> </table></span>
- <span class="cp"></%</span><span class="nb">def</span><span class="cp">></span><span class="x"></span>
- <span class="cp"><%</span><span class="nb">self:layoutdata</span> <span class="na">somedata=</span><span class="s">"${[[1,2,3],[4,5,6],[7,8,9]]}"</span> <span class="na">args=</span><span class="s">"col"</span><span class="cp">></span><span class="x">\</span>
- <span class="x">Body data: </span><span class="cp">${</span><span class="n">col</span><span class="cp">}</span><span class="x">\</span>
- <span class="cp"></%</span><span class="nb">self:layoutdata</span><span class="cp">></span><span class="x"></span>
- </pre></div>
- </div>
- <p>Produces:</p>
- <div class="highlight-html"><div class="highlight"><pre><span class="nt"><table></span>
- <span class="nt"><tr></span>
- <span class="nt"><td></span>Body data: 1<span class="nt"></td></span>
- <span class="nt"><td></span>Body data: 2<span class="nt"></td></span>
- <span class="nt"><td></span>Body data: 3<span class="nt"></td></span>
- <span class="nt"></tr></span>
- <span class="nt"><tr></span>
- <span class="nt"><td></span>Body data: 4<span class="nt"></td></span>
- <span class="nt"><td></span>Body data: 5<span class="nt"></td></span>
- <span class="nt"><td></span>Body data: 6<span class="nt"></td></span>
- <span class="nt"></tr></span>
- <span class="nt"><tr></span>
- <span class="nt"><td></span>Body data: 7<span class="nt"></td></span>
- <span class="nt"><td></span>Body data: 8<span class="nt"></td></span>
- <span class="nt"><td></span>Body data: 9<span class="nt"></td></span>
- <span class="nt"></tr></span>
- <span class="nt"></table></span>
- </pre></div>
- </div>
- <p>You don’t have to stick to calling just the <tt class="docutils literal"><span class="pre">body()</span></tt> function.
- The caller can define any number of callables, allowing the
- <tt class="docutils literal"><span class="pre"><%call></span></tt> tag to produce whole layouts:</p>
- <div class="highlight-mako"><div class="highlight"><pre><span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"layout()"</span><span class="cp">></span>
- <span class="cp">## a layout def</span><span class="x"></span>
- <span class="x"> <div class="mainlayout"></span>
- <span class="x"> <div class="header"></span>
- <span class="x"> </span><span class="cp">${</span><span class="n">caller</span><span class="o">.</span><span class="n">header</span><span class="p">()</span><span class="cp">}</span><span class="x"></span>
- <span class="x"> </div></span>
- <span class="x"> <div class="sidebar"></span>
- <span class="x"> </span><span class="cp">${</span><span class="n">caller</span><span class="o">.</span><span class="n">sidebar</span><span class="p">()</span><span class="cp">}</span><span class="x"></span>
- <span class="x"> </div></span>
- <span class="x"> <div class="content"></span>
- <span class="x"> </span><span class="cp">${</span><span class="n">caller</span><span class="o">.</span><span class="n">body</span><span class="p">()</span><span class="cp">}</span><span class="x"></span>
- <span class="x"> </div></span>
- <span class="x"> </div></span>
- <span class="cp"></%</span><span class="nb">def</span><span class="cp">></span>
- <span class="cp">## calls the layout def</span><span class="x"></span>
- <span class="cp"><%</span><span class="nb">self:layout</span><span class="cp">></span><span class="x"></span>
- <span class="x"> </span><span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"header()"</span><span class="cp">></span><span class="x"></span>
- <span class="x"> I am the header</span>
- <span class="x"> </span><span class="cp"></%</span><span class="nb">def</span><span class="cp">></span><span class="x"></span>
- <span class="x"> </span><span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"sidebar()"</span><span class="cp">></span><span class="x"></span>
- <span class="x"> <ul></span>
- <span class="x"> <li>sidebar 1</li></span>
- <span class="x"> <li>sidebar 2</li></span>
- <span class="x"> </ul></span>
- <span class="x"> </span><span class="cp"></%</span><span class="nb">def</span><span class="cp">></span><span class="x"></span>
- <span class="x"> this is the body</span>
- <span class="cp"></%</span><span class="nb">self:layout</span><span class="cp">></span><span class="x"></span>
- </pre></div>
- </div>
- <p>The above layout would produce:</p>
- <div class="highlight-html"><div class="highlight"><pre><span class="nt"><div</span> <span class="na">class=</span><span class="s">"mainlayout"</span><span class="nt">></span>
- <span class="nt"><div</span> <span class="na">class=</span><span class="s">"header"</span><span class="nt">></span>
- I am the header
- <span class="nt"></div></span>
- <span class="nt"><div</span> <span class="na">class=</span><span class="s">"sidebar"</span><span class="nt">></span>
- <span class="nt"><ul></span>
- <span class="nt"><li></span>sidebar 1<span class="nt"></li></span>
- <span class="nt"><li></span>sidebar 2<span class="nt"></li></span>
- <span class="nt"></ul></span>
- <span class="nt"></div></span>
- <span class="nt"><div</span> <span class="na">class=</span><span class="s">"content"</span><span class="nt">></span>
- this is the body
- <span class="nt"></div></span>
- <span class="nt"></div></span>
- </pre></div>
- </div>
- <p>The number of things you can do with <tt class="docutils literal"><span class="pre"><%call></span></tt> and/or the
- <tt class="docutils literal"><span class="pre"><%namespacename:defname></span></tt> calling syntax is enormous. You can
- create form widget libraries, such as an enclosing <tt class="docutils literal"><span class="pre"><FORM></span></tt>
- tag and nested HTML input elements, or portable wrapping schemes
- using <tt class="docutils literal"><span class="pre"><div></span></tt> or other elements. You can create tags that
- interpret rows of data, such as from a database, providing the
- individual columns of each row to a <tt class="docutils literal"><span class="pre">body()</span></tt> callable which
- lays out the row any way it wants. Basically anything you’d do
- with a “custom tag” or tag library in some other system, Mako
- provides via <tt class="docutils literal"><span class="pre"><%def></span></tt> tags and plain Python callables which are
- invoked via <tt class="docutils literal"><span class="pre"><%namespacename:defname></span></tt> or <tt class="docutils literal"><span class="pre"><%call></span></tt>.</p>
- </div>
- </div>
- <div class="section" id="using-blocks">
- <span id="blocks"></span><h2>Using Blocks<a class="headerlink" href="#using-blocks" title="Permalink to this headline">¶</a></h2>
- <p>The <tt class="docutils literal"><span class="pre"><%block></span></tt> tag introduces some new twists on the
- <tt class="docutils literal"><span class="pre"><%def></span></tt> tag which make it more closely tailored towards layout.</p>
- <p class="versionadded">
- <span class="versionmodified">New in version 0.4.1.</span></p>
- <p>An example of a block:</p>
- <div class="highlight-mako"><div class="highlight"><pre><span class="x"><html></span>
- <span class="x"> <body></span>
- <span class="x"> </span><span class="cp"><%</span><span class="nb">block</span><span class="cp">></span><span class="x"></span>
- <span class="x"> this is a block.</span>
- <span class="x"> </span><span class="cp"></%</span><span class="nb">block</span><span class="cp">></span><span class="x"></span>
- <span class="x"> </body></span>
- <span class="x"></html></span>
- </pre></div>
- </div>
- <p>In the above example, we define a simple block. The block renders its content in the place
- that it’s defined. Since the block is called for us, it doesn’t need a name and the above
- is referred to as an <strong>anonymous block</strong>. So the output of the above template will be:</p>
- <div class="highlight-html"><div class="highlight"><pre><span class="nt"><html></span>
- <span class="nt"><body></span>
- this is a block.
- <span class="nt"></body></span>
- <span class="nt"></html></span>
- </pre></div>
- </div>
- <p>So in fact the above block has absolutely no effect. Its usefulness comes when we start
- using modifiers. Such as, we can apply a filter to our block:</p>
- <div class="highlight-mako"><div class="highlight"><pre><span class="x"><html></span>
- <span class="x"> <body></span>
- <span class="x"> </span><span class="cp"><%</span><span class="nb">block</span> <span class="na">filter=</span><span class="s">"h"</span><span class="cp">></span><span class="x"></span>
- <span class="x"> <html>this is some escaped html.</html></span>
- <span class="x"> </span><span class="cp"></%</span><span class="nb">block</span><span class="cp">></span><span class="x"></span>
- <span class="x"> </body></span>
- <span class="x"></html></span>
- </pre></div>
- </div>
- <p>or perhaps a caching directive:</p>
- <div class="highlight-mako"><div class="highlight"><pre><span class="x"><html></span>
- <span class="x"> <body></span>
- <span class="x"> </span><span class="cp"><%</span><span class="nb">block</span> <span class="na">cached=</span><span class="s">"True"</span> <span class="na">cache_timeout=</span><span class="s">"60"</span><span class="cp">></span><span class="x"></span>
- <span class="x"> This content will be cached for 60 seconds.</span>
- <span class="x"> </span><span class="cp"></%</span><span class="nb">block</span><span class="cp">></span><span class="x"></span>
- <span class="x"> </body></span>
- <span class="x"></html></span>
- </pre></div>
- </div>
- <p>Blocks also work in iterations, conditionals, just like defs:</p>
- <div class="highlight-mako"><div class="highlight"><pre><span class="cp">%</span> <span class="k">if</span> <span class="n">some_condition</span><span class="p">:</span><span class="x"></span>
- <span class="x"> </span><span class="cp"><%</span><span class="nb">block</span><span class="cp">></span><span class="x">condition is met</span><span class="cp"></%</span><span class="nb">block</span><span class="cp">></span>
- <span class="cp">%</span><span class="k"> endif</span><span class="x"></span>
- </pre></div>
- </div>
- <p>While the block renders at the point it is defined in the template,
- the underlying function is present in the generated Python code only
- once, so there’s no issue with placing a block inside of a loop or
- similar. Anonymous blocks are defined as closures in the local
- rendering body, so have access to local variable scope:</p>
- <div class="highlight-mako"><div class="highlight"><pre><span class="cp">%</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">4</span><span class="p">):</span><span class="x"></span>
- <span class="x"> </span><span class="cp"><%</span><span class="nb">block</span><span class="cp">></span><span class="x">i is </span><span class="cp">${</span><span class="n">i</span><span class="cp">}</%</span><span class="nb">block</span><span class="cp">></span>
- <span class="cp">%</span><span class="k"> endfor</span><span class="x"></span>
- </pre></div>
- </div>
- <div class="section" id="using-named-blocks">
- <h3>Using Named Blocks<a class="headerlink" href="#using-named-blocks" title="Permalink to this headline">¶</a></h3>
- <p>Possibly the more important area where blocks are useful is when we
- do actually give them names. Named blocks are tailored to behave
- somewhat closely to Jinja2’s block tag, in that they define an area
- of a layout which can be overridden by an inheriting template. In
- sharp contrast to the <tt class="docutils literal"><span class="pre"><%def></span></tt> tag, the name given to a block is
- global for the entire template regardless of how deeply it’s nested:</p>
- <div class="highlight-mako"><div class="highlight"><pre><span class="x"><html></span>
- <span class="cp"><%</span><span class="nb">block</span> <span class="na">name=</span><span class="s">"header"</span><span class="cp">></span><span class="x"></span>
- <span class="x"> <head></span>
- <span class="x"> <title></span>
- <span class="x"> </span><span class="cp"><%</span><span class="nb">block</span> <span class="na">name=</span><span class="s">"title"</span><span class="cp">></span><span class="x">Title</span><span class="cp"></%</span><span class="nb">block</span><span class="cp">></span><span class="x"></span>
- <span class="x"> </title></span>
- <span class="x"> </head></span>
- <span class="cp"></%</span><span class="nb">block</span><span class="cp">></span><span class="x"></span>
- <span class="x"><body></span>
- <span class="x"> </span><span class="cp">${</span><span class="nb">next</span><span class="o">.</span><span class="n">body</span><span class="p">()</span><span class="cp">}</span><span class="x"></span>
- <span class="x"></body></span>
- <span class="x"></html></span>
- </pre></div>
- </div>
- <p>The above example has two named blocks “<tt class="docutils literal"><span class="pre">header</span></tt>” and “<tt class="docutils literal"><span class="pre">title</span></tt>”, both of which can be referred to
- by an inheriting template. A detailed walkthrough of this usage can be found at <a class="reference internal" href="inheritance.html"><em>Inheritance</em></a>.</p>
- <p>Note above that named blocks don’t have any argument declaration the way defs do. They still implement themselves
- as Python functions, however, so they can be invoked additional times beyond their initial definition:</p>
- <div class="highlight-mako"><div class="highlight"><pre><span class="x"><div name="page"></span>
- <span class="x"> </span><span class="cp"><%</span><span class="nb">block</span> <span class="na">name=</span><span class="s">"pagecontrol"</span><span class="cp">></span><span class="x"></span>
- <span class="x"> <a href="">previous page</a> |</span>
- <span class="x"> <a href="">next page</a></span>
- <span class="x"> </span><span class="cp"></%</span><span class="nb">block</span><span class="cp">></span><span class="x"></span>
- <span class="x"> <table></span>
- <span class="x"> ## some content</span>
- <span class="x"> </table></span>
- <span class="x"> </span><span class="cp">${</span><span class="n">pagecontrol</span><span class="p">()</span><span class="cp">}</span><span class="x"></span>
- <span class="x"></div></span>
- </pre></div>
- </div>
- <p>The content referenced by <tt class="docutils literal"><span class="pre">pagecontrol</span></tt> above will be rendered both above and below the <tt class="docutils literal"><span class="pre"><table></span></tt> tags.</p>
- <p>To keep things sane, named blocks have restrictions that defs do not:</p>
- <ul class="simple">
- <li>The <tt class="docutils literal"><span class="pre"><%block></span></tt> declaration cannot have any argument signature.</li>
- <li>The name of a <tt class="docutils literal"><span class="pre"><%block></span></tt> can only be defined once in a template – an error is raised if two blocks of the same
- name occur anywhere in a single template, regardless of nesting. A similar error is raised if a top level def
- shares the same name as that of a block.</li>
- <li>A named <tt class="docutils literal"><span class="pre"><%block></span></tt> cannot be defined within a <tt class="docutils literal"><span class="pre"><%def></span></tt>, or inside the body of a “call”, i.e.
- <tt class="docutils literal"><span class="pre"><%call></span></tt> or <tt class="docutils literal"><span class="pre"><%namespacename:defname></span></tt> tag. Anonymous blocks can, however.</li>
- </ul>
- </div>
- <div class="section" id="using-page-arguments-in-named-blocks">
- <h3>Using Page Arguments in Named Blocks<a class="headerlink" href="#using-page-arguments-in-named-blocks" title="Permalink to this headline">¶</a></h3>
- <p>A named block is very much like a top level def. It has a similar
- restriction to these types of defs in that arguments passed to the
- template via the <tt class="docutils literal"><span class="pre"><%page></span></tt> tag aren’t automatically available.
- Using arguments with the <tt class="docutils literal"><span class="pre"><%page></span></tt> tag is described in the section
- <a class="reference internal" href="namespaces.html#namespaces-body"><em>The body() Method</em></a>, and refers to scenarios such as when the
- <tt class="docutils literal"><span class="pre">body()</span></tt> method of a template is called from an inherited template passing
- arguments, or the template is invoked from an <tt class="docutils literal"><span class="pre"><%include></span></tt> tag
- with arguments. To allow a named block to share the same arguments
- passed to the page, the <tt class="docutils literal"><span class="pre">args</span></tt> attribute can be used:</p>
- <div class="highlight-mako"><div class="highlight"><pre><span class="cp"><%</span><span class="nb">page</span> <span class="na">args=</span><span class="s">"post"</span><span class="cp">/></span><span class="x"></span>
- <span class="x"><a name="</span><span class="cp">${</span><span class="n">post</span><span class="o">.</span><span class="n">title</span><span class="cp">}</span><span class="x">" /></span>
- <span class="x"><span class="post_prose"></span>
- <span class="x"> </span><span class="cp"><%</span><span class="nb">block</span> <span class="na">name=</span><span class="s">"post_prose"</span> <span class="na">args=</span><span class="s">"post"</span><span class="cp">></span><span class="x"></span>
- <span class="x"> </span><span class="cp">${</span><span class="n">post</span><span class="o">.</span><span class="n">content</span><span class="cp">}</span><span class="x"></span>
- <span class="x"> </span><span class="cp"></%</span><span class="nb">block</span><span class="cp">></span><span class="x"></span>
- <span class="x"></span></span>
- </pre></div>
- </div>
- <p>Where above, if the template is called via a directive like
- <tt class="docutils literal"><span class="pre"><%include</span> <span class="pre">file="post.mako"</span> <span class="pre">args="post=post"</span> <span class="pre">/></span></tt>, the <tt class="docutils literal"><span class="pre">post</span></tt>
- variable is available both in the main body as well as the
- <tt class="docutils literal"><span class="pre">post_prose</span></tt> block.</p>
- <p>Similarly, the <tt class="docutils literal"><span class="pre">**pageargs</span></tt> variable is present, in named blocks only,
- for those arguments not explicit in the <tt class="docutils literal"><span class="pre"><%page></span></tt> tag:</p>
- <div class="highlight-mako"><div class="highlight"><pre><span class="cp"><%</span><span class="nb">block</span> <span class="na">name=</span><span class="s">"post_prose"</span><span class="cp">></span><span class="x"></span>
- <span class="x"> </span><span class="cp">${</span><span class="n">pageargs</span><span class="p">[</span><span class="s">'post'</span><span class="p">]</span><span class="o">.</span><span class="n">content</span><span class="cp">}</span><span class="x"></span>
- <span class="cp"></%</span><span class="nb">block</span><span class="cp">></span><span class="x"></span>
- </pre></div>
- </div>
- <p>The <tt class="docutils literal"><span class="pre">args</span></tt> attribute is only allowed with named blocks. With
- anonymous blocks, the Python function is always rendered in the same
- scope as the call itself, so anything available directly outside the
- anonymous block is available inside as well.</p>
- </div>
- </div>
- </div>
- </div>
- </div>
- <div id="docs-bottom-navigation" class="docs-navigation-links">
- Previous:
- <a href="syntax.html" title="previous chapter">Syntax</a>
- Next:
- <a href="runtime.html" title="next chapter">The Mako Runtime Environment</a>
- <div id="docs-copyright">
- © Copyright the Mako authors and contributors.
- Documentation generated using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3
- with Mako templates.
- </div>
- </div>
- </div>
- <div class="clearfix">
- <hr/>
- <div class="copyright">Website content copyright © by Michael Bayer.
- All rights reserved. Mako and its documentation are licensed
- under the MIT license. mike(&)zzzcomputing.com</div>
- </div>
- </div>
- </body>
- </html>
|