from django.template.loader import render_to_string
+from engine.prelude import Prelude
+
class Plugin:
uid=0
def render (self, request):
uuid = self.uuid
classname = self.classname()
+ # initialize prelude placeholder
+ self._init_request (request)
+
+ # call render_content
plugin_content = self.render_content (request)
-
# expose _settings in json format to js
settings_json = json.dumps(self._settings, separators=(',',':'))
- # xxx missing from the php version
- # compute an 'optionstr' from the set of available settings/options as a json string
- # that gets passed to jquery somehow
- # see the bottom of
result = render_to_string ('widget-plugin.html',
{'uuid':uuid, 'classname':classname,
'visible':self.is_visible(),
'settings_json' : settings_json,
})
+ # handle requirements() if defined on this class
+ try:
+ self.handle_requirements (request, self.requirements())
+ except:
+ import traceback
+ traceback.print_exc()
+ pass
+
return result
# you may redefine this completely, but if you don't we'll just use method
- # template() to find out which template to use, and env() to find out which
- # dictionary to pass the templating system
+ # template() to find out which template to use, and render_env() to compute
+ # a dictionary to pass along to the templating system
def render_content (self, request):
"""Should return an HTML fragment"""
template = self.template()
env=self.render_env(request)
if not isinstance (env,dict):
raise Exception, "%s.render_env returns wrong type"%self.classname()
+ # expose this class's settings to the template
+ # xxx we might need to check that this does not overwrite env..
env.update(self._settings)
result=render_to_string (template, env)
print "%s.render_content: BEG --------------------"%self.classname()
print "%s.render_content: END --------------------"%self.classname()
return result
- def render_env (self, request): return {}
+ #################### requirements/prelude management
+ def _init_request (self, request):
+ if not hasattr (request, 'plugin_prelude'):
+ request.plugin_prelude=Prelude()
+
+ def inspect_request (self, request, message):
+ has=hasattr(request,'plugin_prelude')
+ get=getattr(request,'plugin_prelude','none-defined')
+ print "INSPECT (%s), hasattr %s, getattr %s"%(message,has,get)
+
+ # can be used directly in render_content()
+ def add_js_files (self, request, files):
+ self._init_request (request)
+ request.plugin_prelude.add_js_files (files)
+ def add_css_files (self, request, files):
+ self._init_request (request)
+ request.plugin_prelude.add_css_files (files)
+ def add_js_chunks (self, request, chunks):
+ self._init_request (request)
+ request.plugin_prelude.add_js_chunks (chunks)
+ def add_css_chunks (self, request, chunks):
+ self._init_request (request)
+ request.plugin_prelude.add_css_chunks (chunks)
+
+ # or from the result of self.requirements()
+ def handle_requirements (self, request, d):
+ for (k,v) in d.iteritems():
+ print "%s: handling requirement %s"%(self.classname(),v)
+ method_name='add_'+k
+ method=Plugin.__dict__[method_name]
+ method(self,request,v)
+
######################################## abstract interface
+ def title (self): return "you should redefine title()"
# your plugin is expected to implement either
# (*) def render_content(self, request) -> html fragment
# -- or --
# (*) def template(self) -> filename
+ # relative to STATIC
# (*) def render_env (self, request) -> dict
# this is the variable->value association used to render the template
# in which case the html template will be used
- def title (self): return "you should redefine title()"
-
- # tell the framework about requirements in the document header
- def media_js (self): pass
+ # if you see this string somewhere your template() code is not kicking in
+ def template (self): return "undefined_template"
+ def render_env (self, request): return {}
+
+# # tell the framework about requirements (for the document <header>)
+# # the notion of 'Media' in django provides for medium-dependant
+# # selection of css files
+# # as a first attempt however we keep a flat model for now
+# # can use one string instead of a list or tuple if needed,
+# # see requirements.py for details
+# def requirements (self):
+# return { 'js_files' : [], # a list of relative paths for js input files
+# 'css_files': [], # ditto for css, could have been a dict keyed on
+# # media instead
+# 'js_chunk' : [], # (lines of) verbatim javascript code
+# 'css_chunk': [], # likewise for css scripts
+# }
+
--- /dev/null
+from types import StringTypes, ListType
+
+class Prelude:
+
+ """A class for collecting dependencies on js/css files or fragments"""
+
+ keys=[ 'js_files','css_files','js_chunks', 'css_chunks' ]
+ def __init__ (self):
+ # it's tempting to use sets but sets are not ordered..
+ self.js_files =[]
+ self.css_files =[]
+ self.js_chunks =[]
+ self.css_chunks=[]
+
+ @staticmethod
+ def _normalize (input):
+ if isinstance (input, ListType): return input
+ elif isinstance (input, StringTypes): return [ input ]
+ else: return list (input)
+
+ def add_js_files (self, x):
+ for i in Prelude._normalize (x):
+ if i not in self.js_files: self.js_files.append(i)
+ def add_css_files (self, x):
+ for i in Prelude._normalize (x):
+ if i not in self.css_files: self.css_files.append(i)
+ def add_js_chunks (self, x):
+ self.js_chunks += Prelude._normalize (x)
+ def add_css_chunks (self, x):
+ self.css_chunks += Prelude._normalize (x)
+
+ def render_env (self):
+ env={}
+ env['js_files']= self.js_files
+ env['css_files']= self.css_files
+ env['js_chunks']= '\n'.join(self.js_chunks)
+ env['css_chunks']='\n'.join(self.css_chunks)
+ return env
def test_plugin_view (request):
+ # variables that will get passed to this template
+ template_env = {}
+
# having html tags right here is not a real use case
hard_wired_list=[]
hard_wired_list.append("this hard-wired list")
layout = VerticalLayout (hidable=True, visible=True,
sons=[plugin_main1, plugin_main2]
)
+# layout.inspect_request (request,"before first render")
content_main = layout.render (request)
+# layout.inspect_request (request,"after first render")
+ # this will be rendered as the main content - as per view-plugin.html and thus layout-myslice.html
+ template_env [ 'content_main' ] = content_main
+ ##########
# lacks a/href to /slice/%s
plugin_related = SimpleList (visible=True, hidable=True,
need_datatables='yes',
list=hard_wired_slice_names,
header='Slices' )
content_related = plugin_related.render (request)
+ # likewise but on the side view
+ template_env [ 'content_related' ] = content_related
-
+ # more general variables expected in the template
+ template_env [ 'title' ] = 'Test Plugin View'
+ template_env [ 'topmenu_items' ] = topmenu_items('plugin', request)
+ template_env [ 'username' ] = the_user (request)
+
+ # request.plugin_prelude holds a summary of the requirements() for all plugins
+ # define {js,css}_{files,chunks}
+ prelude_env = request.plugin_prelude.render_env()
+ template_env.update(prelude_env)
- return render_to_response ('view-plugin.html',
- {'title': 'Test Plugin View',
- 'topmenu_items': topmenu_items('plugin', request),
- 'content_main' : content_main,
- 'content_related' : content_related,
- 'username' : the_user (request),
- },
+ return render_to_response ('view-plugin.html',template_env,
context_instance=RequestContext(request))
class SimpleList (Plugin) :
- def template (self): return "simplelist.html"
-
- def media_js (): return [ 'js/simplelist.js' ]
-
- def media_css (): return { 'all': ('css/simplelist.css'), }
-
# SimpleList is useless per se anyways
def title (self) : return "Title for Simple List"
+
+ def template (self): return "simplelist.html"
+
+ def requirements (self):
+ return { 'js_files' : [ "js/simplelist.js" ],
+ 'css_files': [ "css/simplelist.css" ],
+# for tests
+# 'js_chunks' : "/* a javascript chunk */",
+# 'css_chunks': "/* a css style */ ",
+ }
--- /dev/null
+/* simplelist.js */
from django.template.loader import render_to_string
-from engine.plugin import Plugin
+from engine.composite import Composite
-class VerticalLayout (Plugin) :
+class VerticalLayout (Composite) :
- def __init__ (self, sons=[], *args, **kwds):
- self.sons=sons
- Plugin.__init__ (self, *args, **kwds)
-
- def insert (self, plugin):
- self.sons.append(plugin)
-
def title (self) : return "VLayout title"
+ def template (self): return "verticallayout.html"
+
def render_env (self, request):
env = {}
sons_rendered = [ son.render(request) for son in self.sons ]
for id,rendered,title in zip (ids, sons_rendered, sons_titles) ]
env['sons']=sons
return env
-
-
- def template (self): return "verticallayout.html"
-
- def media_js (): return [ 'js/simplelist.js' ]
-
- def media_css (): return { 'all': ('css/simplelist.css'), }
<meta name="viewport" content="width=device-width, initial-scale=1.0">
{# This is where insert_str will end up #}
{% media_container prelude %}
-{% insert_str prelude "jquery/js/jquery.js" %}
-{% insert_str prelude "bootstrap/js/bootstrap.js" %}
-{% insert_str prelude "bootstrap/css/bootstrap.css" %}
-{% insert_str prelude "js/plugin.js" %}
<script type="text/javascript">
{# In case we need to add raw js code - use {% insert prelude_js %} ... {% endinsert %} #}
{% container prelude_js %}
+{{ js_chunks }}
</script>
<style type="text/css">
{# In case we need to add raw css code #}
{% container prelude_css %}
+{{ css_chunks }}
</style>
</head>
-{# let's add this one no matter what #}
+{# let's add these ones no matter what #}
+{% insert_str prelude "jquery/js/jquery.js" %}
+{% insert_str prelude "bootstrap/js/bootstrap.js" %}
+{% insert_str prelude "bootstrap/css/bootstrap.css" %}
+{% insert_str prelude "js/plugin.js" %}
{% insert_str prelude "css/myslice.css" %}
+{# also add the stuff as collected in a Prelude class #}
+{% for js_file in js_files %} {% insert_str prelude js_file %} {% endfor %}
+{% for css_file in css_files %} {% insert_str prelude css_file %} {% endfor %}
+
<body>
{% block container %}
{% endblock content_main %}
{% block content_related %}
-{% insert_str prelude "datatables/js/dataTables.js" %}
-{% insert_str prelude "js/need-datatables.js" %}
-{% insert_str prelude "css/simplelist.css" %}
-
{{ content_related|safe }}
{% endblock content_related %}
{# <a id='menu_logo' href="/"><img class="logo" src="{{ STATIC_URL }}img/myslice-logo.png" alt="MySlice" /></a> #}
-{# {% insert_str prelude "js/mymenu.js" %} #}
{% insert_str prelude "css/topmenu.css" %}
<div id='topmenu' class="navbar navbar-fixed-top">
git://git.onelab.eu / unfold.git / commitdiff