# BEGIN INCLUDE
from tdi import html
from tdi.tools.html import decode
# This is some typcial flash embedding code.
# It serves as a "layout widget", placed via overlay
flash = html.from_string("""
<!-- <tdi> is used as neutral dummy element (removed due to the - flag) -->
<tdi tdi:scope="-flash" tdi:overlay="<-flash">
<object tdi="object_ie"
classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" width=""
height="">
<param tdi="url" name="movie" value="" />
<param tdi="param" />
<![if !IE]><object tdi="object_other"
type="application/x-shockwave-flash" data="" width="" height="">
<param tdi="param" />
<![endif]>
<p tdi="alternative">You need to enable <a
href="http://www.adobe.com/go/getflashplayer">Flash</a> to view this
content.</p>
<![if !IE]></object><![endif]></object>
</tdi>
""")
# page template, using the flash layout widget, passing parameters
template = html.from_string("""
<html>
<body>
<h1>some flash</h1>
<tdi tdi:scope="-flash.param" tdi="-init"
#!/usr/bin/env python
import warnings as _warnings
_warnings.resetwarnings()
_warnings.filterwarnings('error')
from tdi.model_adapters import RenderAdapter
from tdi import html
template = html.from_string("""
<anode tdi="level1">
<node tdi="-*nested">
<xnode tdi="a"></xnode>
</node>
<ynode tdi="-*:nested">lalala</ynode>
</anode>
""".lstrip())
class Model(object):
def render_a(self, node):
node.content = u'hey'
model = Model()
template.render(model, adapter=RenderAdapter.for_prerender)
#!/usr/bin/env python
import warnings as _warnings
_warnings.resetwarnings()
_warnings.filterwarnings('error')
import re as _re
from tdi import html
from tdi.tools import javascript
tpl = html.from_string("""
<a tdi="link" onclick="alert('__what__'); return false">Click me</a>
""".lstrip())
json = javascript.LiteralJSON(u'{"name": "Andr\xe9]]>"}')
class Model(object):
def render_link(self, node):
javascript.fill_attr(node, u'onclick', dict(
what = u'Andr\xe9',
))
tpl.render(Model())
tpl = html.from_string("""
<a tdi="link" onclick="alert('__what__'); return false">Click me</a>
""".lstrip())
json = javascript.LiteralJSON(u'{"name": "Andr\xe9]]>"}')
class Model(object):
def render_link(self, node):
javascript.fill_attr(node, u'onclick', dict(
what = json,
))
tpl.render(Model())
#!/usr/bin/env python
import warnings as _warnings
_warnings.resetwarnings()
_warnings.filterwarnings('error')
from tdi.model_adapters import RenderAdapter
from tdi import html
template = html.from_string("""
<anode tdi="level1" tdi:prerender="remove-node">
<node tdi="-nested">
<xnode tdi="a">
<znode tdi="b">foo</znode>
</xnode>
</node>
<ynode tdi="-:nested">lalala</ynode>
</anode>
""".lstrip())
class Model(object):
def render_a(self, node):
node.b.content = u'hey'
node.b.hiddenelement = True
node.b['tdi:prerender'] = u'remove-node'
model = Model()
template.render(model, adapter=RenderAdapter.for_prerender)
#!/usr/bin/env python
import warnings as _warnings
_warnings.resetwarnings()
_warnings.filterwarnings('error')
from tdi import html
template = html.from_string("""
<node tdi="item">
<node tdi="nested">
<node tdi="subnested"></node>
</node>
<xnode tdi="a"></xnode>
</node>
""".lstrip())
class Model(object):
def render_item(self, node):
node.nested.replace(self.replace_nested, node.a)
return True
def replace_nested(self, node):
node['been'] = u'here'
node.content = u'yes'
def render_a(self, node):
node.content = u"should not be here"
model = Model()
template.render(model)
#!/usr/bin/env python
import warnings as _warnings
_warnings.resetwarnings()
_warnings.filterwarnings('error')
from tdi import html
template = html.from_string("""
<node tdi="item">
<node tdi="nested">
<node tdi="subnested"></node>
</node><tdi tdi=":-nested">
</tdi>
</node>
""".lstrip())
class Model(object):
def render_item(self, node):
for subnode, item in node.nested.iterate([1, 2, 3, 4]):
subnode['j'] = item
subnode.content = u'should be here %s' % item
if item == 3:
break
model = Model()
template.render(model)
#!/usr/bin/env python
import warnings as _warnings
_warnings.resetwarnings()
_warnings.filterwarnings('error')
from tdi import html
from tdi.model_adapters import PreRenderWrapper, RenderAdapter
template = html.from_string("""
<foo>
<bar tdi:overlay=">-foo"/>
</foo>
""".lstrip()).overlay(html.from_string("""
<tdi tdi:overlay="-foo">
<script tdi="test">JAVASCRIPT</script>
</tdi>
""".lstrip()))
class Model(object):
def render_test(self, node):
node.raw.content = node.raw.content.replace('SCR', ' hey ')
def adapter(model):
return PreRenderWrapper(RenderAdapter(model))
model = Model()
html.from_string(template.render_string(None, adapter=adapter)).render(
model, startnode="test"
)
print
""" HTML minifier factory """
return html_tools.MinifyFilter(builder, comment_filter=keep_foo)
# 3. Template Factory
html = html.replace(eventfilters=[
# ...
html_minifyfilter, # instead of html_tools.MinifyFilter
# ...
])
# 4. Do your thing.
tpl = html.from_string("""
<html>
<head>
<!-- Here comes the title -->
<title>Hello World!</title>
<style>
Some style.
</style>
</head>
<body>
<!-- foo -->
<script>
Some script.
</script>
<h1>Hello World!</h1>
<!-- bar -->
</body>
""".lstrip())
tpl.render()
#!/usr/bin/env python
import warnings as _warnings
_warnings.resetwarnings()
_warnings.filterwarnings('error')
from tdi import html
template = html.from_string("""
<node>
<xnode tdi="zonk" tdi:scope="foo"></xnode>
</node>
""".lstrip())
class FooModel(object):
def render_zonk(self, node):
node.content = u"Yay."
class Model(object):
def __init__(self):
self.scope_foo = FooModel()
model = Model()
template.render(model)
#!/usr/bin/env python
import warnings as _warnings
_warnings.resetwarnings()
_warnings.filterwarnings('error')
# BEGIN INCLUDE
from tdi import html
from tdi.tools import htmlform
template = html.from_string("""
<html>
<body>
<p>Type your name:</p>
<form tdi="form">
<div tdi="-name">
<p tdi="*error" class="error">Error message</p>
<input tdi="*field" id="name" type="text" />
</div>
<input tdi="submit" type="submit" />
</form>
</body>
</html>
""")
class Model(object):
def __init__(self, errors=None):
self._errors = errors or {}
self._form = htmlform.HTMLForm(
pre_proc=self.preproc,
post_proc=htmlform.TabIndexer(),
)
import warnings as _warnings
_warnings.resetwarnings()
_warnings.filterwarnings("error")
from tdi import html
template = html.from_string(
"""
<node tdi="item">
<znode tdi="nested" tdi:overlay="foo">
<ynode tdi="subnested"></ynode>
</znode>
<xnode tdi="a"></xnode>
</node>
""".lstrip()
).overlay(
html.from_string(
"""
<anode tdi="grumpf" tdi:overlay="-foo">
<bnode tdi="gna"></bnode>
</anode>
""".lstrip()
)
)
class Model(object):
def render_nested(self, node):
node["been"] = u"here"
def render_gna(self, node):
#!/usr/bin/env python
import warnings as _warnings
_warnings.resetwarnings()
_warnings.filterwarnings('error')
from tdi.model_adapters import RenderAdapter
from tdi import html
template = html.from_string("""
<anode tdi="level1">
<node tdi="-nested" tdi:scope="foo.bar" tdi:overlay="ov">
<xnode tdi="a" tdi:scope="baz"></xnode>
</node>
<ynode tdi="-:nested">lalala</ynode>
</anode>
""".lstrip()).overlay(html.from_string("""
<znode tdi:scope="zonk">
<widget tdi:overlay="ov">widget!</widget>
</znode>
""".lstrip()))
template.render(None, adapter=RenderAdapter.for_prerender)
#!/usr/bin/env python
import warnings as _warnings
_warnings.resetwarnings()
_warnings.filterwarnings('error')
from tdi import html
template = html.from_string("""
<anode tdi="level1">
<node tdi="*level2">
<node tdi="level3">
hey.
</node>
</node>
</anode>
""".lstrip())
class Model(object):
def render_level2(self, node):
node['foo'] = 'bar'
def render_level3(self, node):
node.content = 'sup.'
model = Model()
template.render(model)
#!/usr/bin/env python
import warnings as _warnings
_warnings.resetwarnings()
_warnings.filterwarnings('error')
from tdi import html
from tdi.tools import javascript
html = html.replace(eventfilters=[javascript.CDATAFilter])
tpl = html.from_string("""
<html>
<script src="foo"></script>
<script><!--
//--></script>
<script><!--
var x=1;
var y = 2;
alert( x + y );
//--></script>
<script tdi="bar"><!--
--></script>
</html>
""".lstrip())
tpl.render()
#!/usr/bin/env python
import warnings as _warnings
_warnings.resetwarnings()
_warnings.filterwarnings('error')
from tdi import html
template = html.from_string("""
<node tdi="item">
<znode tdi:overlay="foo">
<ynode tdi:overlay="bar"></ynode>
<ynode tdi:overlay="<zonk"></ynode>
<ynode tdi:overlay=">plenk"></ynode>
</znode>
<xnode tdi:overlay=">baz"></xnode>
</node>
""".lstrip())
print list(sorted(template.source_overlay_names))
print list(sorted(template.target_overlay_names))
#!/usr/bin/env python
import warnings as _warnings
_warnings.resetwarnings()
_warnings.filterwarnings('error')
from tdi import html
template = html.from_string("""
<node>
<xnode></xnode>
</node>
""".lstrip())
print template
print template.tree
template.render()
#!/usr/bin/env python
import warnings as _warnings
_warnings.resetwarnings()
_warnings.filterwarnings('error')
from tdi import html
template = html.from_string("""
<html>
<body>
<ul>
<li tdi="menu"><a tdi="link">some menu item</a></li>
</ul>
</body>
</html>
""")
class Model(object):
def __init__(self, menu, page):
self._menu = menu
self._page = page
# BEGIN INCLUDE
def render_menu(self, node):
node.repeat(self.repeat_menu, self._menu)
def repeat_menu(self, node, (href, menuitem)):
node.link.content = menuitem
if (node.ctx[0] + 1 == self._page):
node.link.hiddenelement = True
else:
node.link['href'] = href
#!/usr/bin/env python
import warnings as _warnings
_warnings.resetwarnings()
_warnings.filterwarnings('error')
import os
os.chdir(os.path.dirname(os.path.abspath(os.path.normpath(__file__))))
# BEGIN INCLUDE
from tdi import html
from tdi import factory
template = html.from_string("""
<html>
<body tdi="body">
some template
</body>
</html>
""")
print template.tree
template = html.from_file('loading.html')
print template.tree
stream = open('loading.html')
try:
template = html.from_stream(stream)
finally:
stream.close()
print template.tree
#!/usr/bin/env python
import warnings as _warnings
_warnings.resetwarnings()
_warnings.filterwarnings('error')
# BEGIN INCLUDE
from tdi import html
content = html.from_string("""
<html>
<body>
<h1 tdi="doctitle">doc title goes here</h1>
<ul tdi:overlay="menu"></ul>
<p tdi="intro" class="edit-intro">Intro goes here.</p>
<div class="list" tdi="list">
...
</div>
</body>
</html>
""")
menu_widget = html.from_string("""
<html>
<body>
<ul tdi:overlay="menu">
<li tdi="menu"><a tdi="link">some menu item</a></li><li tdi=":-menu">
</li>
</ul>
</body>
</html>
""")
class Model(object):
#!/usr/bin/env python
import warnings as _warnings
_warnings.resetwarnings()
_warnings.filterwarnings('error')
from tdi import html
template = html.from_string("""
<node tdi="item">
<znode tdi="nested" tdi:overlay="foo">
<ynode tdi="subnested"></ynode>
</znode>
<xnode tdi=":nested" tdi:overlay="bar"> separator </xnode>
</node>
""".lstrip()).overlay(html.from_string("""
<anode tdi:overlay="foo"> overlayed </anode>
""".lstrip()))
class Model(object):
def render_nested(self, node):
for subnode, item in node.iterate([0, 1]):
subnode.content = item
model = Model()
template.render(model)
#!/usr/bin/env python
import warnings as _warnings
_warnings.resetwarnings()
_warnings.filterwarnings('error')
# BEGIN INCLUDE
from tdi import html
from tdi.tools import htmlform
template = html.from_string("""
<html>
<body>
<p>Type your name:</p>
<form tdi="form">
<input tdi="name" type="text" />
<input tdi="submit" type="submit" />
</form>
</body>
</html>
""")
class Model(object):
def __init__(self):
self._form = htmlform.HTMLForm(post_proc=htmlform.TabIndexer())
def render_form(self, node):
self._form.form(node)
def render_name(self, node):
self._form.text(node, u"name")
def render_submit(self, node):
#!/usr/bin/env python
import warnings as _warnings
_warnings.resetwarnings()
_warnings.filterwarnings("error")
from tdi import html
template = html.from_string(
"""
<?xml version="1.0" encoding="utf-8" ?>
<node>
<xnode tdi="foo"></xnode>
</node>
""".lstrip()
)
class Model(object):
def render_foo(self, node):
try:
node[u"b\xe9lah"] = u"bl\xf6d"
except UnicodeError:
node[u"blah"] = u"bl\xf6d"
template.render(Model())
#!/usr/bin/env python
import warnings as _warnings
_warnings.resetwarnings()
_warnings.filterwarnings('error')
# BEGIN INCLUDE
from tdi import html
template = html.from_string("""
<html>
<body>
<h1 tdi="doctitle">doc title goes here</h1>
<ul class="menu">
<li><a href="menu1" tdi="menu1">some menu item</a></li>
<li><a href="menu2" tdi="menu2">Editing Content & Attributes</a></li>
<li><a href="menu3" tdi="menu3">Other menu item</a></li>
</ul>
<p tdi="intro" class="edit-intro">Intro goes here.</p>
<div class="list" tdi="list">
...
</div>
</body>
</html>
""")
class Model(object):
def __init__(self, possibilities, page):
self._possibilities = possibilities
self._page = page
def render_doctitle(self, node):
node.content = u"Editing Content & Attributes"
#!/usr/bin/env python
import warnings as _warnings
_warnings.resetwarnings()
_warnings.filterwarnings('error')
from tdi.model_adapters import RenderAdapter
from tdi import html
template = html.from_string("""
<anode tdi="level1">
<node tdi="-nested" tdi:scope="foo.bar">
<xnode tdi="a" tdi:scope="baz"></xnode>
</node>
<ynode tdi="-:nested">lalala</ynode>
</anode>
""".lstrip())
template.render(None, adapter=RenderAdapter.for_prerender)
#!/usr/bin/env python
import warnings as _warnings
_warnings.resetwarnings()
_warnings.filterwarnings('error')
from tdi import html
template = html.from_string("""
<node tdi="item">
<znode tdi:overlay="foo">
<ynode tdi="subnested"></ynode>
</znode>
</node>
""".lstrip())
class Model(object):
def render_subnested(self, node):
node.content = u"yeah."
model = Model()
template.render(model, startnode="item.subnested")
print
#!/usr/bin/env python
import warnings as _warnings
_warnings.resetwarnings()
_warnings.filterwarnings('error')
from tdi import html
from tdi.tools import css
html = html.replace(eventfilters=[
css.CDATAFilter,
css.MinifyFilter,
])
tpl = html.from_string("""
<html>
<style><!--
--></style>
<style><!--
a b c{
foo: bar;
baz: blub;
}
--></style>
<style tdi="bar"><!--
--></style>
</html>
""".lstrip())
tpl.render()
#!/usr/bin/env python
import warnings as _warnings
_warnings.resetwarnings()
_warnings.filterwarnings('error')
from tdi import html
template = html.from_string("""
<html>
<body>
<ul class="menu" tdi="menu">
<li><a href="menu1" tdi="*menu1">some menu item</a></li>
<li><a href="menu2" tdi="*menu2">Editing Content & Attributes</a></li>
<li><a href="menu3" tdi="*menu3">Other menu item</a></li>
</ul>
</body>
</html>
""")
class Model(object):
def __init__(self, page):
self._page = page
def render_menu(self, node):
node("menu%d" % self._page).hiddenelement = True
def render_menu1(self, node):
node.content = "shouldn't come here..."
model = Model(page=2)
template.render(model)
Submitted by: Jens Michlo
"""
import warnings as _warnings
_warnings.resetwarnings()
_warnings.filterwarnings('error')
from tdi import html
template = html.from_string("""
<tdi tdi="-items">
<tdi tdi="-item">
<tdi tdi="-product">
Produtcs
</tdi>
<tdi tdi="-offer">
Offer
</tdi>
<tdi tdi="-leer">
leer
</tdi>
</tdi>
</tdi>
""".lstrip())
class Model(object):
def _render(self, subnode, item):
print "OK", item
def render_items(self, node):
items = [1 ,2 ,3]
#!/usr/bin/env python
import warnings as _warnings
_warnings.resetwarnings()
_warnings.filterwarnings('error')
# BEGIN INCLUDE
from tdi import html
from tdi.tools import javascript
template = html.from_string("""
<html>
<body>
<tdi tdi="-script">
<div tdi="*html"><h1 tdi="h1">dynamic js-only-content</h1></div>
<script tdi="*script">
document.write('__html__')
</script>
</tdi>
</body>
</html>
""".lstrip())
class Model2(object):
def render_h1(self, node):
node.content = u"different."
class Model(object):
def render_h1(self, node):
node.content = u"My Heading"
#!/usr/bin/env python
import warnings as _warnings
_warnings.resetwarnings()
_warnings.filterwarnings('error')
# BEGIN INCLUDE
from tdi import html
template = html.from_string("""
<html>
<body>
<p>My fruit salad contains <tdi tdi="-fruit">Apples</tdi><tdi
tdi=":-fruit">, </tdi>.</p>
</body>
</html>
""".lstrip())
class Model(object):
def __init__(self, fruits):
self._fruits = fruits
def render_fruit(self, node):
node.repeat(self.repeat_fruit, self._fruits, len(fruits) - 2)
def repeat_fruit(self, node, fruit, last_sep_idx):
node.content = fruit
def separate_fruit(self, node, last_sep_idx):
if node.ctx[0] == last_sep_idx:
node.content = u' and '
