def template(templatename, pattern=None):
    """
    Load XML template
    """
    return loaders.xmlfile(templatename, 
                           templateDir=config.TEMPLATE_PATH,
                           pattern=pattern)

 def __init__(self, original, ctx, factory):
     self.factory = factory  
     self.user = self.factory.getUser(original)
     rend.Page.__init__(self, original)
     
     r = manager.ResourceManager()
     UserAdmin.docFactory = loaders.xmlfile( r["resources"]["web"]["user_admin.html"] )

 def render_content(self, ctx, data):
     role = self.getRole(ctx)
     
     if role == 0:
         return self.renderAlert('You are not authorized')
     
     return loaders.xmlfile(webappPath('agent/index.html'))

    def getDocFactory(self, fragmentName, default=None):
        """
        For a given fragment, return a loaded Nevow template.

        @param fragmentName: the name of the template (can include relative
        paths).

        @param default: a default loader; only used if provided and the
        given fragment name cannot be resolved.

        @return: A loaded Nevow template.
        @type return: L{nevow.loaders.xmlfile}
        """
        if fragmentName in self.cachedLoaders:
            return self.cachedLoaders[fragmentName]
        segments = fragmentName.split('/')
        segments[-1] += '.html'
        file = self.directory
        for segment in segments:
            file = file.child(segment)
        if file.exists():
            loader = xmlfile(file.path)
            self.cachedLoaders[fragmentName] = loader
            return loader
        return default

    def test_docFactoryInStanTree(self):

        class Page(rend.Page):

            def __init__(self, included):
                self.included = included
                rend.Page.__init__(self)

            def render_included(self, context, data):
                return self.included
            
            docFactory = loaders.stan(div[invisible(render=directive('included'))])

        doc = '<p>fum</p>'
        temp = self.mktemp()
        f = file(temp, 'w')
        f.write(doc)
        f.close()

        result = deferredRender(Page(loaders.stan(p['fee'])))
        self.assertEquals(result, '<div><p>fee</p></div>')
        result = deferredRender(Page(loaders.htmlstr('<p>fi</p>')))
        self.assertEquals(result, '<div><p>fi</p></div>')
        result = deferredRender(Page(loaders.xmlstr('<p>fo</p>')))
        self.assertEquals(result, '<div><p>fo</p></div>')
        result = deferredRender(Page(loaders.htmlfile(temp)))
        self.assertEquals(result, '<div><p>fum</p></div>')
        result = deferredRender(Page(loaders.xmlfile(temp)))
        self.assertEquals(result, '<div><p>fum</p></div>')

 def macro_content(self, ctx):
     return t.invisible[
                t.p["This macro has been called ",
                    next(counter2)+1,
                    " time(s)"],
                loaders.xmlfile(util.sibpath(__file__,'child_macro.html'), ignoreDocType=True).load()
         ]

    def __init__(self, parent, package=None, webServer=None, name=None):
        """
        Pass me a 'parent' rendering component,
        a 'package' that I'm rendering for
        and a 'webServer' instance reference (from webServer.py)
        If you don't pass 'webServer' and 'package' I'll
        get them from 'parent'
        'name' is a identifier to distuniguish us from the other children of our
        parent
        """
        self.parent = parent # This is the same for both blocks and pages
        if name:
            self.name = name
        elif not self.name:
            raise AssertionError('Element of class "%s" created with no name.' %
                                 self.__class__.__name__)
            
        # Make pylint happy. These attributes will be gotten from
        # self.application
        self.config = Unset
        self.ideviceStore = Unset
        self.packageStore = Unset

        # Overwrite old instances with same name
        if parent:
            parent.renderChildren[self.name] = self
        self.renderChildren = {}
        if package:
            self.package = package
        elif parent:
            self.package = parent.package
        else:
            self.package = None
        if webServer:
            self.webServer = webServer
        elif parent:
            self.webServer = parent.webServer
        else:
            self.webServer = None
        if self._templateFileName:
            if hasattr(self, 'config') and self.config:
                pth = self.config.webDir/'templates'/self._templateFileName
                self.docFactory = loaders.xmlfile(pth)
            else:
                # Assume directory is included in the filename
                self.docFactory = loaders.xmlfile(self._templateFileName)

 def test_xmlfile(self):
     doc = '<ul id="nav"><li>a</li><li>b</li><li>c</li></ul>'
     temp = self.mktemp()
     f = file(temp, 'w')
     f.write(doc)
     f.close()
     df = loaders.xmlfile(temp)
     self.assertEquals(df.load()[0], doc)

 def __init__(self, original, options=None, otherOption=None):
     self.original = original
     if options is not None:
         self.options = options
     if otherOption is not None:
         self.otherOption = otherOption
     if self.template is None:
         self.template = loaders.xmlfile(util.resource_filename('formal',
             'html/SelectOtherChoice.html'))

	def __init__(self, *args, **kwargs):
		zoto_base_page.__init__(self, *args, **kwargs)
		self.album_id = -1
		self.offset = 0
		self.username = args[0]
		self.album_id = args[1]
		self.can_view = False
		self.docFactory = loaders.xmlfile(os.path.join(self.tpl_path, "album_template.xml"))
		self.template_path = "%s/album_templates" % aztk_config.setup.get("paths", "web")

 def test_xmlfilePreprocessors(self):
     """
     Test that the xmlstr loader properly passes uncompiled documents to
     preprocessors it is given.
     """
     xmlFile = self.mktemp()
     f = file(xmlFile, 'w')
     f.write('<div><span>Hello</span><span>world</span></div>')
     f.close()
     factory = loaders.xmlfile(xmlFile)
     return self._preprocessorTest(factory)

    def run(self):
        kwargs = {}
        template = self.get('template', None)
        if template is not None:
            kwargs['docFactory'] = loaders.xmlfile(template)

        feed = readFeed(self.path)
        a = Atom(feed, **kwargs)
        d = a.renderString()
        d.addCallback(self._print)
        return d

    def getfiles(self,nodes):
        for node in nodes:
            if len(node) == 4:
                self.getfiles(node[3])

            try:
                newpage = rend.Page()
                newpage.docFactory = loaders.xmlfile(node[2],templateDir='apidoc')
            except Exception,e:
                pass
            else:
                self.children[node[1]] = newpage

def getHtml(yamlfile, countItems, template):
    ydata = list(yaml.loadFile(yamlfile))[0]
    Page.docFactory = loaders.xmlfile(template)

    d = Page(ydata, countItems).renderString()

    output = []
    d.addCallback(cb, output)
    d.addErrback(eb)
    reactor.run()

    return output[0]

    def test_xmlFileInStanTree(self):
        """
        Like L{test_htmlStringInStanTree}, but for an xmlfile loader.
        """
        doc = '<p>I</p>'
        temp = self.mktemp()
        f = file(temp, 'w')
        f.write(doc)
        f.close()

        return self._testDocFactoryInStanTree(
            loaders.xmlfile(temp),
            '<p>I</p>')

 def workloadType(self, ctx, wltypeName):
     session = inevow.ISession(ctx) 
     if self.workloadTypes is None:
         self.workloadTypes = yield session.agent.expsvcAgent.getWorkloadTypes(agentId = self.agentId)
     
     wltype = self.workloadTypes[wltypeName]
     
     wlcDescriptions = [T.li[wlclasses[wlc][1]]
                        for wlc 
                        in wltype.wlclass]
     
     ctx.fillSlots('name', wltypeName)
     ctx.fillSlots('module', wltype.module)
     ctx.fillSlots('path', wltype.path)
     ctx.fillSlots('classes', T.ul()[wlcDescriptions])
     
     self.data_workloadParams = []
     
     for paramName, param in wltype.params.iteritems():
                 if param.flags & TSWLParamCommon.WLPF_OPTIONAL:
                     paramName = T.span[paramName,
                                        T.sup['OPT']]
                 
                 wlpType = WLParamHelper.getTypeName(param)
                 
                 minVal, maxVal = WLParamHelper.getIntegerRange(param)
                 lenVal = WLParamHelper.getStringLength(param)
                 range = 'None'
                 
                 if minVal is not None and maxVal is not None:
                     range = '[%s...%s]' % (_wlparamToStr(minVal, param), 
                                            _wlparamToStr(maxVal, param))
                 elif lenVal is not None:
                     range = 'len: %s' % lenVal
                 
                 default = WLParamHelper.getDefaultValue(param)
                 if default is not None:
                     default = _wlparamToStr(default, param)
                 else:
                     default = 'None'
                 
                 self.data_workloadParams.append({'param': paramName, 
                                                  'type': wlpType, 
                                                  'range': range, 
                                                  'default': default, 
                                                  'description': param.description})
     
     wltparams = loaders.xmlfile(webappPath('agent/wltypeparam.html'))
     
     returnValue(wltparams)

    def renderHTTP(self, ctx):
        """
        Check for a confirmation being used from the email link.

        If the user is confirming a login, move the password from
        unconfirmedPassword into password, thus enabling the account.
        """
        req = inevow.IRequest(ctx)
        confirm = req.args.get('confirm', None) 
        if confirm is not None:
            confirm = unicode(confirm[0])
            store = theGlobal['database']
            u = store.findFirst(data.User, data.User.confirmationKey==confirm)
            if u is not None:
                u.password = u.unconfirmedPassword
                u.unconfirmedPassword = None
                req.args.clear()
                self.docFactory = loaders.xmlfile(
                        RESOURCE('templates/confirmed.xhtml'))
            else:
                self.docFactory = loaders.stan(['Could not confirm that account.'])
        return super(SignupPage, self).renderHTTP(ctx)

    def __init__(self, parent, package):
        """
        Initialize a new XUL page
        'package' is the package that we look after
        """
        self.name = package.name
        RenderableLivePage.__init__(self, parent, package)
        self.putChild("resources", static.File(package.resourceDir))

        mainxul = Path(self.config.xulDir).joinpath('templates', 'mainpage.xul')
        self.docFactory  = loaders.xmlfile(mainxul)

        # Create all the children on the left
        self.outlinePane = OutlinePane(self)
        self.idevicePane = IdevicePane(self)
        self.styleMenu   = StyleMenu(self)

        # And in the main section
        self.authoringPage  = AuthoringPage(self)
        self.propertiesPage = PropertiesPage(self)

        # translate the "don't close the window" message
        red_x = _("Please use eXe's\n   File... Quit\nmenu to close eXe.")

 def agentCommonInfo(self, ctx):
     agentInfo = self.agentInfo
     clientInfo = self.clientInfo
     
     if clientInfo is None:
         clientStateImg = T.img(src = '/images/cl-status/dead.png')
         clientState = 'disconnected'
         
         clientId = 'N/A'
         clientUuid = 'N/A'
         clientEndpoint = 'N/A'
     else:
         clientStateImg = T.img(src = '/images/cl-status/established.png')
         clientState = 'established'
         
         clientId = clientInfo.id
         clientUuid = clientInfo.uuid
         clientEndpoint = clientInfo.endpoint
     
     for slot, data in [('hostname', agentInfo.hostname),
                         ('domainname', agentInfo.domainname),
                         ('osname', agentInfo.osname),
                         ('release', agentInfo.release),
                         ('arch', agentInfo.machineArch),
                         ('numCPUs', agentInfo.numCPUs),
                         ('numCores', agentInfo.numCores),
                         ('memTotal', agentInfo.memTotal),
                         ('agentId', agentInfo.agentId),
                         ('lastOnline', agentInfo.lastOnline),
                         ('clientStateImg', clientStateImg),
                         ('clientState', clientState),
                         ('clientId', clientId),
                         ('clientUuid', clientUuid),
                         ('clientEndpoint', clientEndpoint)]:
             ctx.fillSlots(slot, data)
         
     return loaders.xmlfile(webappPath('agent/loadinfoagent.html'))

 def docFactory(self):
     return loaders.xmlfile(_tpl.path)