Пример #1
0
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)
Пример #2
0
 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)]])
Пример #3
0
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))]
Пример #4
0
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]
Пример #5
0
 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]
Пример #6
0
 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]
Пример #7
0
        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)
Пример #8
0
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], ], ], ])
Пример #9
0
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
Пример #10
0
 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))
Пример #11
0
 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))
Пример #12
0
 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
Пример #13
0
 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>"
     )
Пример #14
0
 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) ]
Пример #15
0
 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)
     ]
Пример #16
0
        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]
Пример #17
0
	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)
Пример #18
0
	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)
Пример #19
0
 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]]
Пример #20
0
 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>")
Пример #21
0
    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'))]
Пример #22
0
 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])+']);')
     ]
Пример #23
0
 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
Пример #24
0
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 []
Пример #25
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
Пример #26
0
	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)
Пример #27
0
	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)
Пример #28
0
    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
                           ]) + ']);')]
Пример #29
0
        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)
Пример #30
0
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)]]])
Пример #31
0
    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])
Пример #32
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
Пример #33
0
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,
                ],
            ]
        )
Пример #34
0
    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
                    ]
                )
                + "]);"
            ),
        ]
Пример #35
0
 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>')
Пример #36
0
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"), ]]]])
Пример #37
0
        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
Пример #38
0
    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]
Пример #39
0
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)
Пример #40
0
    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>'
        )
Пример #41
0
    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>')
Пример #42
0
 def createPageLink(pageId, pageTitle, isActive=False):
     _ = pagin[T.li(_class='active' if isActive else '')[T.a(
         onclick=livepage.server.handle('page',
                                        pageId), href='#')[pageTitle]]]
Пример #43
0
 def createPageLink(pageId, pageTitle, isActive=False):
     _ = pagin[T.li(_class = 'active' if isActive else '')[
                    T.a(onclick=livepage.server.handle('page', pageId),
                        href='#')[pageTitle]]]
Пример #44
0
 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
Пример #45
0
 def _menu(items, class_):
     for item in items:
         yield T.li(class_=class_)[T.a(href=item.get_url(),
                                       class_=class_)[item.title]]
Пример #46
0
    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)})
            ]
            ]
Пример #47
0
 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]] ]
Пример #48
0
 def render_test(context, data):
     return tags.ul(render=rend.sequence)[
             tags.li(pattern='item')[
                 'foo', (((tags.invisible(data=tags.directive('foo'), render=str),),),)
             ]
         ]
Пример #49
0
 def renderItem(self, error, level):
     return T.li(class_=level)[error]
Пример #50
0
 def _menu(items, class_):
     for item in items:
         yield T.li(class_=class_)[T.a(href=item.get_url(),
                                       class_=class_)[item.title]]
Пример #51
0
 def renderItem (self, error, level):
         return T.li ( class_ = level ) [ error ]
Пример #52
0
 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]]]
Пример #53
0
 def renderList(self, ctx, data):
     return [
         T.li(class_='folder')[T.a(href=dir)[dir]]
         for dir in listdir(self.repository + "/sheets")
     ]
Пример #54
0
 def renderList (self, ctx, data):
     return [T.li (class_='folder')[
                 T.a(href= dir)[dir]
                 ] for dir in listdir(self.repository + "/sheets") ]
Пример #55
0
 def render_test(context, data):
     return tags.ul(render=rend.sequence)[
             tags.li(pattern='item')[
                 'foo', (((tags.invisible(data=tags.directive('foo'), render=str),),),)
             ]
         ]
Пример #56
0
 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]]