class Root(TransactionalPage):
child_webform_css = webform.defaultCSS
implements(IInsert)
docFactory = loaders.stan(t.html[
t.head[t.title['Imagination'],
t.link(rel='stylesheet',
type='text/css',
href=url.root.child('webform_css'))],
t.body[webform.renderForms(),
t.ul(render=t.directive("sequence"), data=t.directive("images")
)[t.li(pattern="item", render=t.directive("image")),
t.li(pattern="empty")["No images yet"]]]])
def data_images(self, ctx, data):
return IImages(self.store).getImages(15)
def render_image(self, ctx, data):
return t.a(href=url.root.child('fs').child(data.hash))[data.title]
def insert(self, ctx, title, author, image):
img = Image(store=self.store,
image=image.value,
title=title.decode('utf-8'),
author=author.decode('utf-8'),
hash=label().decode('utf-8'))
def locateChild(self, ctx, segments):
if segments[0] == 'fs':
data = IImages(self.store).getOne(segments[1].decode('utf-8'))
return static.Data(data.image, 'image/jpeg'), ()
return super(Root, self).locateChild(ctx, segments)
def buildStanTree(Tree, mstan, itr=0, bigcnt=0, lastDom=None):
which = 1
if Tree.children:
# This is a branch
bigcnt += 1
if Tree.name == 'dm':
if Settings.defaultDomain == repr(Tree):
groupUrl = tags.li(_class="groupsm.png")[tags.a(
href="/auth/Users/GroupMod/%s/" % (repr(Tree)),
id="node_%s" % (bigcnt + 1, ),
title="Modify groups")["Edit Groups"]]
else:
groupUrl = [
tags.li(_class="domdel.gif")
[tags.
a(href="/auth/Users/DomainDel/%s/" % (repr(Tree)),
id="node_%s" % (bigcnt + 2),
title="Delete this domain",
onclick=
"return confirm('Are you sure you want to delete this domain?');"
)["Delete Domain"]],
]
extra = [
tags.li(_class="dhtmlgoodies_add.gif")[tags.a(
href="/auth/Users/Add/%s/" % (repr(Tree)),
title="Add new user",
id="node_%s" % bigcnt)["Add User"]], groupUrl
]
else:
extra = tags.li(_class="domadd.gif")[tags.a(
href="/auth/Users/DomainAdd/",
id="node_%s" % bigcnt,
title="Add new domain")["Add Domain"]]
mstan.children.append(tags.li[
tags.a(href='/auth/Users/' + repr(Tree), id="node_%s" %
bigcnt)[repr(Tree)], tags.ul[extra]])
lastDom = repr(Tree)
for Branch in Tree.children:
buildStanTree(Branch,
mstan.children[-1].children[-1],
itr=itr + 1,
bigcnt=itr + which + bigcnt,
lastDom=lastDom)
which += 1
else:
# This is the end of a limb
if sel == repr(Tree):
icon = "dhtmlgoodies_selected.gif"
else:
icon = "dhtmlgoodies_sheet.gif"
if lastDom == 'Domains':
mstan.children.append(tags.li[tags.a(
href="/auth/Users/Add/%s" % (repr(Tree)),
id="node_%s" % bigcnt)[repr(Tree)]])
else:
mstan.children.append(
tags.li(_class=icon)[tags.a(
href="/auth/Users/Edit/%s/%s" % (lastDom, repr(Tree)),
id="node_%s" % bigcnt)[repr(Tree)]])
class Root(rend.Page):
implements(ITodo)
child_css = webform.defaultCSS
docFactory = loaders.stan(
t.html(render=t.directive("time"))[
t.head[
t.title['todo'],
t.style(type="text/css")[".done { color: #dddddd; }"],
t.style(type="text/css")["@import url(/css);"]
],
t.body[
webform.renderForms(),
t.ul(data=t.directive("findAll"),
render=t.directive("sequence"))[
t.li(pattern="item",render=t.directive('todo')),
t.li(pattern="empty",render=t.directive('empty')),
],
t.p(render=t.directive("end"))
]
]
)
def insert(self, ctx, description):
return itodo.ITodos(ctx).add(description, 0)
def delete(self, ctx, id):
return itodo.ITodos(ctx).delete(id)
def update(self, ctx, id, oldstate):
newstate = [1, 0][oldstate]
return itodo.ITodos(ctx).update(id, newstate)
def data_findAll(self, ctx, data):
return itodo.ITodos(ctx).findAll()
def render_todo(self, ctx, data):
deluri = "freeform_post!!delete?id="+str(data[0])
updateuri = "freeform_post!!update?id="+str(data[0])+"&oldstate="+str(data[2])
state = [" Done", " To Do"][int(data[2])==0]
tag = ctx.tag
if data[2]:
tag = ctx.tag(_class="done")
return tag[data[1]+" - ",
t.a(href=deluri)["Delete"], " / ",
t.a(href=updateuri)[("Mark Done", "Mark Undone")[data[2]]],
state]
def render_empty(self, ctx, data):
return ctx.tag["No Todos"]
def render_time(self, ctx, data):
ctx.remember(now(), itodo.ITimer)
return ctx.tag
def render_end(self, ctx, data):
return ctx.tag["%.3f"%(now()-itodo.ITimer(ctx))]
class Root(rend.Page):
addSlash = True
docFactory = loaders.stan(
t.html[t.head[t.title["Nested Sequence"]], t.body[t.ul(
data=t.directive("vertexes"), render=t.directive("sequence"))[t.li(
pattern="item"
)[t.span(data=t.directive("name"), render=t.directive("string")),
t.ul(data=t.directive('edges'), render=t.directive("sequence")
)[t.li(pattern="item", render=t.directive("string"))]]]]])
def data_vertexes(self, ctx, data):
return [v1, v2, v3]
def render_links(self, context, data):
ds = self.root.edits(self.ob)
therange = range(len(ds))
rev = therange[self.rev]
ul = tags.ul()
for i in therange:
li = tags.li()
if i:
li[tags.a(href=url.URL.fromContext(context).sibling(
'diff').add(
'ob', self.ob.fullName()).add(
'revA', i-1).add(
'revB', i))["(diff)"]]
else:
li["(diff)"]
li[" - "]
if i == len(ds) - 1:
label = "Latest"
else:
label = str(i)
if i == rev:
li[label]
else:
li[tags.a(href=url.gethere.replace('rev', str(i)))[label]]
li[' - ' + ds[i].user + '/' + ds[i].time]
ul[li]
return context.tag[ul]
def render_links(self, context, data):
ds = self.root.edits(self.ob)
therange = range(len(ds))
rev = therange[self.rev]
ul = tags.ul()
for i in therange:
li = tags.li()
if i:
li[tags.a(href=url.URL.fromContext(
context).sibling('diff').add('ob', self.ob.fullName()).add(
'revA', i - 1).add('revB', i))["(diff)"]]
else:
li["(diff)"]
li[" - "]
if i == len(ds) - 1:
label = "Latest"
else:
label = str(i)
if i == rev:
li[label]
else:
li[tags.a(href=url.gethere.replace('rev', str(i)))[label]]
li[' - ' + ds[i].user + '/' + ds[i].time]
ul[li]
return context.tag[ul]
class R(rend.Page):
def data_numbers(context, data):
return ['one', 'two', 'three']
tags = ul(data=data_numbers, render=directive('sequence'))[li(
pattern='item')[span(render=str)]]
docFactory = loaders.stan(tags)
class Page(rend.Page):
def render_item(self, ctx, data):
return inevow.IRenderer(data)
docFactory = loaders.stan(
T.html[T.body[T.ul(data=objs, render=rend.sequence)[T.li(
pattern='item')[render_item], ], ], ])
class DBBrowser(rend.Page):
implements(IAddItem)
addSlash = True
def addItem(self, newSubject):
doQuery('insert into foo values subject = "%s"', newSubject)
def data_queryDatabase(self, context, data):
return doQuery('select * from foo')
def render_row(self, context, data):
theId, theSubj = data
return context.tag[ # put our anchor in the li provided by the template
tags.a(href=theId)[theSubj]]
docFactory = loaders.stan(tags.html[tags.body[
tags.h1["Welcome, user"],
tags.ul(data=tags.directive("queryDatabase"),
render=tags.directive("sequence")
)[tags.li(pattern="item", render=render_row)],
webform.renderForms()]])
def childFactory(self, ctx, name):
"""Since we created anchor tags linking to children of this resource
directly by id, when the anchor is clicked, childFactory will be called
with the appropriate id as the name argument."""
try:
## Pass the id of the database item we want to be rendered on this page
## to the DBItem constructor. This integer will be used as the default data
## for this page.
return DBItem(int(name))
except ValueError:
pass
def _():
for n, (tab, page) in enumerate(pages):
tID = '%s_tab_%i'%(name, n)
pID = '%s_page_%i'%(name, n)
yield (t.li(id_=tID)[tab],
t.div(id_=pID)[page],
flt(js[tID,pID], quote = False))
def _():
for n, (tab, page) in enumerate(pages):
tID = '%s_tab_%i'%(name, n)
pID = '%s_page_%i'%(name, n)
yield (t.li(class_='nevow-tabbedpane-tab', id_=tID)[tab],
t.div(class_='nevow-tabbedpane-pane', id_=pID)[page],
flt(js[tID,pID], quote = False))
def render_images(self, ctx, data):
"""Render a list of images.
"""
tag = T.div(data=images, render=rend.sequence)[T.div(pattern='item')[
T.p(data=T.directive('filename'), render=T.directive('data')),
T.ul(data=T.directive('comments'), render=rend.sequence)[
T.li(pattern='item', render=T.directive('data')), ], ], ]
return tag
def test_patterns(self):
tag = tags.html[tags.body[tags.ol(
data=["one", "two", "three"],
render=rend.sequence)[tags.li(pattern="item")[str]]]]
self.assertEquals(
self.render(tag),
"<html><body><ol><li>one</li><li>two</li><li>three</li></ol></body></html>"
)
def renderList (self, ctx, data):
"Renders page's body"
path = "/".join([self.repository, "sheets"]+
inevow.IRequest(ctx).prepath[1:])
return [ T.li (class_='sheet') [
T.a (href = "/".join([dir, version]))
[ dir + "-" + version ]
] for dir in listdir(path)
for version in listdir(path + '/' + dir) ]
def renderList(self, ctx, data):
"Renders page's body"
path = "/".join([self.repository, "sheets"] +
inevow.IRequest(ctx).prepath[1:])
return [
T.li(class_='sheet')[T.a(href="/".join([dir, version]))[dir + "-" +
version]]
for dir in listdir(path) for version in listdir(path + '/' + dir)
]
def _render(self, ctx, key, args, errors, value, tag):
def data_facets(ctx, data):
storeSession = util.getStoreSession(ctx)
avatar = util.getAvatar(ctx)
@defer.deferredGenerator
def loadCategories(facets):
d = defer.waitForDeferred(avatar.getCategoryManager(storeSession))
yield d
categories = d.getResult()
rv = []
for f in facets:
facetData = FacetData()
facetData.label = f[2]
facetData.textid = f[1]
rv.append(facetData)
d = defer.waitForDeferred(categories.loadCategories(facetData.textid))
yield d
facetData.tree = d.getResult().children
yield rv
d = avatar.getCategoryManager(storeSession)
d.addCallback(lambda categories: categories.loadFacets())
d.addCallback(loadCategories)
return d
def render_facet(ctx, data):
tag = ctx.tag
tag.fillSlots("facetlabel", data.label)
return tag
def render_node(ctx, data):
tag = ctx.tag
tag.fillSlots("value", data.path)
tag.fillSlots("label", data.label)
if data.path in value:
tag.children[0] = tag.children[0](checked="checked")
else:
tag.children[0](checked=None)
return tag
template = T.div(class_="categorieswidget")[
T.p(class_="opener")["click to open/close"],
T.ul(class_="panel", data=data_facets, render=rend.sequence)[
T.li(pattern="item", render=render_facet)[
T.slot("facetlabel"),
T.div(data=T.directive("tree"), render=tree.render)[
T.invisible(pattern="item", render=render_node)[tag, T.slot("label")]
],
]
],
]
return T.invisible()[template]
def data_identities(self, ctx, data): """ Template function to display a list of user identities. """ result = yield self.user.getIdentities() output = [tags.h3()['identities'], tags.ul(_class="url-list")[[ tags.li()[item['url']] for item in result ]] ] returnValue(output)
def data_trusted_roots(self, ctx, data): """ Template function to display a list of user roots. """ result = yield self.user.getTrustedRoots() output = [tags.h3()['trusted roots'], tags.ul(_class="url-list")[[ tags.li()[item['url']] for item in result ]] ] returnValue(output)
def render_tooltip(self, ctx, data):
return T.invisible[
T.a(_class="tt")[" [?] "],
T.span(_class="tooltip")[
T.div(_class="tooltipactions")[
T.ul[
T.li(_class="closetooltip")[
" [ ",
T.a(href="#")["close"],
" ]"]]],
data]]
def test_patterns(self):
tag = tags.html[
tags.body[
tags.ol(data=["one", "two", "three"], render=rend.sequence)[
tags.li(pattern="item")[
str
]
]
]
]
self.assertEqual(self.render(tag), "<html><body><ol><li>one</li><li>two</li><li>three</li></ol></body></html>")
def render_content(self, ctx, data):
toolbar = [
("/mail/New/", 'New', "/images/inbox.png", "newmail"),
("#", 'Delete', "/images/inbox.png", "deletesel"),
]
return ctx.tag[tags.ul(id="mailTools")[[
tags.li(id=id)[tags.a(href=link)[tags.div[tags.img(src=image)],
name]]
for link, name, image, id in toolbar
]],
tags.invisible(render=tags.directive('thisFragment'))]
def tabbedPane(self, ctx, data):
tab_names = [element[0] for element in data]
return t.invisible[
t.div(class_='tabbedPane')[
t.ul(class_='tabs')[
[t.li(id_="tab-"+name.replace(' ', '_'))[name] for name in tab_names]
],
[t.div(id_="page-"+name.replace(' ', '_'))[fragment] for name, fragment in data]
],
t.inlineJS('setupTabbedPane(['+','.join([le.flt(le.js['tab-'+name.replace(' ', '_'),'page-'+name.replace(' ', '_')], quote=False) for name, junk in data])+']);')
]
def render_images(self, ctx, data):
"""Render a list of images.
"""
tag = T.div(data=images, render=rend.sequence)[
T.div(pattern='item')[
T.p(data=T.directive('filename'), render=T.directive('data')),
T.ul(data=T.directive('comments'), render=rend.sequence)[
T.li(pattern='item', render=T.directive('data')),
],
],
]
return tag
class Mine(rend.Page):
addSlash = True
docFactory = loaders.stan(T.html[T.head[T.title["This is title"]], T.body[
T.h1(id="header")["Welcome"],
T.ol(data=directive("theList"), render=directive("sequence"))[
T.span(pattern="header")["HEADER"],
T.li(pattern="item")["Stuff: ",
T.span(render=directive("string")), "!"],
T.span(pattern="divider")["-----"],
T.div(pattern="empty")["Nothing."],
T.span(pattern="footer")["FOOTER"], ],
T.ol(data=directive("empty"), render=directive("sequence"))[
T.span(pattern="header")["HEADER"],
T.li(pattern="item")["Stuff: ",
T.span(render=directive("string")), "!"],
T.span(pattern="divider")["-----"],
T.div(pattern="empty")["Nothing."],
T.span(pattern="footer")["FOOTER"], ],
T.span(render=directive("foo"))[
"This entire node, including the span tag, will be replaced by \
a randomly chosen node from below:",
T.div(pattern="one", style="color: red")["one"],
T.table(pattern="two")[T.tr[T.td["two"], T.td["two"],
T.td["two"]]],
T.ol(pattern="three")[T.li["three"], T.li["three"],
T.li["three"], ]]]])
def render_foo(self, context, data):
return inevow.IQ(context).onePattern(
random.choice(['one', 'two', 'three']))
def data_theList(self, context, data):
return [random.randint(0, 5000) for x in range(random.randint(0, 10))]
def data_empty(self, context, data):
return []
def subclassesFrom(hostsystem, cls, anchors):
r = tags.li()
name = cls.fullName()
if name not in anchors:
r[tags.a(name=name)]
anchors.add(name)
r[taglink(cls), ' - ', epydoc2stan.doc2html(cls, summary=True)[0]]
scs = [sc for sc in cls.subclasses if sc.system is hostsystem and ' ' not in sc.fullName()
and sc.isVisible]
if len(scs) > 0:
ul = tags.ul()
for sc in sorted(scs, key=_lckey):
ul[subclassesFrom(hostsystem, sc, anchors)]
r[ul]
return r
def data_trusted_roots(self, ctx, data): """ Template function to display a checkbox list of user roots. """ result = yield self.user.getTrustedRoots() output = [tags.h3()['trusted roots'], tags.ul(_class="url-list")[[ tags.li()[[ tags.input(type='checkbox', name='root-%s' % item['id'], value='1'), item['url'], ]] for item in result ]] ] returnValue(output)
def data_identities(self, ctx, data): """ Template function to display a checkbox list of user identities. """ result = yield self.user.getIdentities() output = [tags.h3()['identities'], tags.ul(_class="url-list")[[ tags.li()[[ tags.input(type='checkbox', name='identity-%s' % item['id'], value='1'), item['url'], ]] for item in result ]] ] returnValue(output)
def tabbedPane(self, ctx, data):
tab_names = [element[0] for element in data]
return t.invisible[t.div(class_='tabbedPane')[t.ul(class_='tabs')[[
t.li(id_="tab-" + name.replace(' ', '_'))[name]
for name in tab_names
]], [
t.div(id_="page-" + name.replace(' ', '_'))[fragment]
for name, fragment in data
]],
t.inlineJS('setupTabbedPane([' + ','.join([
le.flt(le.js['tab-' + name.replace(' ', '_'),
'page-' + name.replace(' ', '_')],
quote=False) for name, junk in data
]) + ']);')]
def gotRoot(item,tag):
nodepath = node.path.split('.')
nodedepth = len(nodepath)
try:
title = node.label
except TypeError:
return defer.succeed('')
t = T.li()[T.a(href=urlForNode(node))[title]]
tag[t]
if requestPath == nodepath:
t = t(class_="selected")
return defer.succeed(tag)
class VirtualHostList(rend.Page):
def __init__(self, nvh):
rend.Page.__init__(self)
self.nvh = nvh
stylesheet = """
body { border: 0; padding: 0; margin: 0; background-color: #efefef; }
h1 {padding: 0.1em; background-color: #777; color: white; border-bottom: thin white dashed;}
"""
def getStyleSheet(self):
return self.stylesheet
def data_hostlist(self, context, data):
return self.nvh.hosts.keys()
def render_hostlist(self, context, data):
host = data
req = context.locate(inevow.IRequest)
proto = req.clientproto.split('/')[0].lower()
port = req.getHeader('host').split(':')[1]
link = "%s://%s" % (proto, host)
if port != 80:
link += ":%s" % port
link += req.path
return context.tag[tags.a(href=link)[host]]
def render_title(self, context, data):
req = context.locate(inevow.IRequest)
proto = req.clientproto.split('/')[0].lower()
host = req.getHeader('host')
return context.tag["Virtual Host Listing for %s://%s" % (proto, host)]
def render_stylesheet(self, context, data):
return tags.style(type="text/css")[self.getStyleSheet()]
docFactory = loaders.stan(tags.html[tags.head[
tags.title(render=render_title),
tags.directive('stylesheet'), ], tags.body[
tags.h1(render=render_title),
tags.ul(data=directive("hostlist"), render=directive("sequence")
)[tags.li(pattern="item", render=render_hostlist)]]])
def endKey(self, atom):
children = [c for c in self.resultTree.pop() if c]
# see enterValue on why we're doing this
if (self.resultTree[-1] and self.resultTree[-1][-1] is None):
return
if len(children) > 1:
childElements = []
for c in children:
if self._isCompound(c) > 1:
class_ = "compoundMetaItem"
else:
class_ = "metaItem"
childElements.append(T.li(class_=class_)[c])
self.resultTree[-1].append(T.ul(class_="metaEnum")[childElements])
elif len(children) == 1:
self.resultTree[-1].append(children[0])
def subclassesFrom(hostsystem, cls, anchors):
r = tags.li()
name = cls.fullName()
if name not in anchors:
r[tags.a(name=name)]
anchors.add(name)
r[taglink(cls), ' - ', epydoc2stan.doc2html(cls, summary=True)[0]]
scs = [
sc for sc in cls.subclasses if sc.system is hostsystem
and ' ' not in sc.fullName() and sc.isVisible
]
if len(scs) > 0:
ul = tags.ul()
for sc in sorted(scs, key=_lckey):
ul[subclassesFrom(hostsystem, sc, anchors)]
r[ul]
return r
class Page(rend.Page):
addSlash = True
def render_one(self, ctx, data):
return IFullView(random.choice(objs))
docFactory = loaders.stan(
T.html[
T.body[
T.ul(data=objs, render=rend.sequence)[
T.li(pattern='item')[lambda c,d: ISummaryView(d)]
],
T.hr,
render_one,
],
]
)
def tabbedPane(self, ctx, data):
tab_names = [element[0] for element in data]
return t.invisible[
t.div(class_="tabbedPane")[
t.ul(class_="tabs")[[t.li(id_="tab-" + name.replace(" ", "_"))[name] for name in tab_names]],
[t.div(id_="page-" + name.replace(" ", "_"))[fragment] for name, fragment in data],
],
t.inlineJS(
"setupTabbedPane(["
+ ",".join(
[
le.flt(le.js["tab-" + name.replace(" ", "_"), "page-" + name.replace(" ", "_")], quote=False)
for name, junk in data
]
)
+ "]);"
),
]
def test_cloning(self):
def data_foo(context, data): return [{'foo':'one'}, {'foo':'two'}]
def render_test(context, data):
return tags.ul(render=rend.sequence)[
tags.li(pattern='item')[
'foo', (((tags.invisible(data=tags.directive('foo'), render=str),),),)
]
]
document = tags.html(data=data_foo)[
tags.body[
tags.ul(render=rend.sequence)[
tags.li(pattern='item')[
tags.a(href=('test/', tags.invisible(data=tags.directive('foo'), render=str)))['link']
]
],
render_test
]
]
document=self.render(document, precompile=True)
self.assertEquals(self.render(document), '<html><body><ul><li><a href="test/one">link</a></li><li><a href="test/two">link</a></li></ul><ul><li>fooone</li><li>footwo</li></ul></body></html>')
class RecentChangesPage(page.Element):
def __init__(self, root, url):
self.root = root
self.url = url
@page.renderer
def changes(self, request, tag):
item = tag.patternGenerator('item')
for d in reversed(self.root._edits):
tag[util.fillSlots(item,
diff=self.diff(d),
hist=self.hist(d),
object=util.taglink(d.obj),
time=d.time,
user=d.user)]
return tag
def diff(self, data):
return tags.a(href=self.url.sibling('diff').add(
'ob', data.obj.fullName()).add('revA', data.rev -
1).add('revB', data.rev))["(diff)"]
def hist(self, data):
return tags.a(href=self.url.sibling('history').add(
'ob', data.obj.fullName()).add('rev', data.rev))["(hist)"]
docFactory = loaders.stan(tags.html[
tags.head[
tags.title["Recent Changes"],
tags.link(rel="stylesheet", type="text/css", href='apidocs.css')],
tags.body[tags.h1["Recent Changes"], tags.p[
"See ",
tags.a(
href="bigDiff")["a diff containing all changes made online"]],
tags.ul(render=tags.directive("changes"))[tags.li(
pattern="item")[tags.slot("diff"), " - ",
tags.slot("hist"), " - ",
tags.slot("object"), " - ",
tags.slot("time"), " - ",
tags.slot("user"), ]]]])
def gotItem(item, tag, node, urlpath):
nodepath = node.path.split('.')
nodedepth = len(nodepath)
try:
title = node.label
except TypeError:
return defer.succeed('')
# If we're not showing submenus (apart from the selected item)
# then loop through our urlpath and check that the node matches each segment.
# If it doesn't then return our result so far
if not self.openall:
for n, segment in enumerate(urlpath[:self.openallbelow]):
if n+1>=nodedepth or segment != nodepath[n+1]:
return defer.succeed(tag)
t = T.li()[T.a(href=urlForNode(node))[title]]
tag[t]
# Mark selected item
if requestPath[:nodedepth] == nodepath[:nodedepth]:
t = t(class_="selectedpath")
if requestPath == nodepath:
t = t(class_="selected")
# only show up to a set depth
if self.maxdepth is not None and nodedepth > self.maxdepth:
return defer.succeed(tag)
if node.children and (self.openall or requestPath[:nodedepth] == nodepath[:nodedepth]):
s = T.ul()
t[s]
d = addChildren(s, node, urlpath,isRoot=False)
else:
d = defer.succeed(tag)
return d
def flatDirs(self, d, bigcnt=1, start=True, chain=""):
bigcnt *= 10
if not d:
return
stack = []
keys = d.keys()
keys.sort()
for k in keys:
v = d[k]
bigcnt += 1
chainc = chain + "." + k
if k == "INBOX":
k = "Inbox"
fclass = "mail-inbox.png"
elif k.lower() == "sent":
k = "Sent"
fclass = "mail-sent.png"
else:
fclass = "mail-folder.png"
node = [
tags.a(href="#",
_class="treeNode %s" % chainc.strip('.'),
id="node_%s" % bigcnt)[k]
]
rec = self.flatDirs(v, bigcnt, False, chainc)
if rec:
node.append(rec)
stack.append(tags.li(_class=fclass)[node])
if start:
return tags.ul(id="tree", _class="ctree")[stack]
else:
return tags.ul[stack]
class DataEntry(rend.Page):
"""Add Animal"""
addSlash = 1
docFactory = loaders.stan(
T.html[T.body[T.h1[
"First, a Setup Form."],
T.h2["Enter some animals as data. Click 'Done' to test looking up these animals."],
T.h3["The neat stuff happens when you hit 'Done'."],
webform.renderForms(),
T.ol(data=T.directive("animals"), render=rend.sequence)[
T.li(pattern="item", render=T.directive("string")),
],
T.h1[T.a(href=url.here.child('typeahead'))["Done"]],
]
]
)
def bind_animals(self, ctx, ):
"""Add Animal"""
return annotate.MethodBinding(
'animals',
annotate.Method(arguments=
[annotate.Argument('animal', annotate.String()),
annotate.Argument('description', annotate.Text())]),
action="Add Animal",
)
def animals(self, animal, description):
"""Add Animal"""
if not (animal and description):
return
animals[animal.decode('utf-8')] = description.decode('utf-8')
return url.here
def data_animals(self, ctx, data):
return list(animals.keys())
def child_typeahead(self, ctx):
return TypeAheadPage(None, None)
def test_cloning(self):
def data_foo(context, data):
return [{'foo': 'one'}, {'foo': 'two'}]
# tests nested lists without precompilation (precompilation flattens the lists)
def render_test(context, data):
return tags.ul(render=rend.sequence)[tags.li(
pattern='item')['foo', (((
tags.invisible(data=tags.directive('foo'), render=str), ),
), )]]
# tests tags inside attributes (weird but useful)
document = tags.html(data=data_foo)[tags.body[tags.ul(
render=rend.sequence)[tags.li(pattern='item')[tags.a(
href=('test/',
tags.invisible(data=tags.directive('foo'), render=str)
))['link']]], render_test]]
document = self.render(document, precompile=True)
self.assertEquals(
self.render(document),
'<html><body><ul><li><a href="test/one">link</a></li><li><a href="test/two">link</a></li></ul><ul><li>fooone</li><li>footwo</li></ul></body></html>'
)
def test_cloning(self):
def data_foo(context, data): return [{'foo':'one'}, {'foo':'two'}]
# tests nested lists without precompilation (precompilation flattens the lists)
def render_test(context, data):
return tags.ul(render=rend.sequence)[
tags.li(pattern='item')[
'foo', (((tags.invisible(data=tags.directive('foo'), render=str),),),)
]
]
# tests tags inside attributes (weird but useful)
document = tags.html(data=data_foo)[
tags.body[
tags.ul(render=rend.sequence)[
tags.li(pattern='item')[
tags.a(href=('test/', tags.invisible(data=tags.directive('foo'), render=str)))['link']
]
],
render_test
]
]
document=self.render(document, precompile=True)
self.assertEqual(self.render(document), '<html><body><ul><li><a href="test/one">link</a></li><li><a href="test/two">link</a></li></ul><ul><li>fooone</li><li>footwo</li></ul></body></html>')
def createPageLink(pageId, pageTitle, isActive=False):
_ = pagin[T.li(_class='active' if isActive else '')[T.a(
onclick=livepage.server.handle('page',
pageId), href='#')[pageTitle]]]
def createPageLink(pageId, pageTitle, isActive=False):
_ = pagin[T.li(_class = 'active' if isActive else '')[
T.a(onclick=livepage.server.handle('page', pageId),
href='#')[pageTitle]]]
def build_menuitem(self, name, selected):
menu = self.find_menu(name)
menuitem = tags.li()[tags.a(href=menu['url'])[menu['label']]]
if selected == name:
menuitem.attributes['class'] = 'selected'
return menuitem
def _menu(items, class_):
for item in items:
yield T.li(class_=class_)[T.a(href=item.get_url(),
class_=class_)[item.title]]
def render(self, ctx, key, args, errors):
if errors:
images = args.get(key, [''])[0]
images = self._parseValue(images)
else:
images = iforms.ISequenceConvertible(self.original).fromType(args.get(key))
if images is None:
images = []
imgs = T.ul(id="artwork_list_"+keytocssid(ctx.key))
for image in images:
imgs[ T.li(id='item_%s'%image)[
T.img(src='/artwork/system/assets/%s/mainImage?size=100x100'%image , class_="preview"),
T.a(onClick='delete_item(%s);'%image)['delete']
] ]
return T.div()[
imgs, T.br(),
T.textarea(name=key, id=keytocssid(ctx.key))['\n'.join(images)], T.br(),
T.button(onclick="return ArtworkPicker('%s')"%keytocssid(ctx.key))['Choose artwork ...'],
T.script(type="text/javascript")[
T.xml("""
function ArtworkPicker(elementId, type) {
var url = '/artwork/system/assets/artworkbrowser';
url = url + '?searchOwningId='+elementId+'&searchType='+type;
var popup = window.open(url, 'ArtworkPicker', 'height=500,width=900,resizable,scrollbars');
popup.focus();
return false;
}
function imageListChanged(sortable) {
var items = MochiKit.Sortable.Sortable.serialize(sortable).split('&');
var newOrder=[];
for(i=0;i<items.length;i++){
var item = items[i];
var id = item.split('=')[1];
newOrder.push(id);
}
var ta=document.getElementById('%(key)s');
ta.value='';
for(i=0;i<newOrder.length;i++) {
ta.value=ta.value+'\\n'+newOrder[i];
}
}
function itemAdded() {
MochiKit.Sortable.Sortable.create('artwork_list_%(key)s',{onUpdate:imageListChanged});
}
function delete_item(delete_id) {
var element=document.getElementById('item_'+delete_id);
removeElement(element);
var ta=document.getElementById('%(key)s');
var ids = ta.value.split('\\n');
ta.value='';
for(i=0;i<ids.length;i++) {
id = ids[i];
if(delete_id==id) {
continue;
}
ta.value=ta.value+'\\n'+id;
}
}
function setup() {
connect('artwork_list_%(key)s', 'itemAdded', itemAdded);
signal('artwork_list_%(key)s', 'itemAdded');
}
setup();
"""%{'key': keytocssid(ctx.key)})
]
]
def renderItem (self, item, location):
if path.isdir(location+item) :
return T.li ( class_ = 'folder' ) [ T.a (href=item) [item] ]
elif path.isfile(location+item) :
return T.li ( class_ = item.split(".")[-1] ) [ T.a (href=item) [item.split(".")[:-1]] ]
def render_test(context, data):
return tags.ul(render=rend.sequence)[
tags.li(pattern='item')[
'foo', (((tags.invisible(data=tags.directive('foo'), render=str),),),)
]
]
def renderItem(self, error, level):
return T.li(class_=level)[error]
def _menu(items, class_):
for item in items:
yield T.li(class_=class_)[T.a(href=item.get_url(),
class_=class_)[item.title]]
def renderItem (self, error, level):
return T.li ( class_ = level ) [ error ]
def renderItem(self, item, location):
if path.isdir(location + item):
return T.li(class_='folder')[T.a(href=item)[item]]
elif path.isfile(location + item):
return T.li(class_=item.split(".")[-1])[T.a(
href=item)[item.split(".")[:-1]]]
def renderList(self, ctx, data):
return [
T.li(class_='folder')[T.a(href=dir)[dir]]
for dir in listdir(self.repository + "/sheets")
]
def renderList (self, ctx, data):
return [T.li (class_='folder')[
T.a(href= dir)[dir]
] for dir in listdir(self.repository + "/sheets") ]
def render_test(context, data):
return tags.ul(render=rend.sequence)[
tags.li(pattern='item')[
'foo', (((tags.invisible(data=tags.directive('foo'), render=str),),),)
]
]
def render_tooltip(self, ctx, data):
return T.invisible[
T.a(_class="tt")[" [?] "],
T.span(_class="tooltip")[T.div(_class="tooltipactions")[T.ul[T.li(
_class="closetooltip")[" [ ",
T.a(href="#")["close"], " ]"]]], data]]
