def media(self):
view = self.view
if view is not None:
if not hasattr(self, '_media'):
m = view.default_media(self.request)
if m is None:
m = media.Media(settings=view.settings)
self._media = m
return self._media
class ColorInput(html.TextInput):
classes = 'color-picker span2'
_media = media.Media(js=[
'color/colorpicker/jquery.colorpicker.js',
'color/colorpicker/i18n/jquery.ui.colorpicker-en.js', 'color/color.js'
])
def set_value(self, value, widget):
if value and value.startswith('#'):
value = value[1:]
widget.addAttr('value', value)
class ChatApplication(views.Application):
_media = media.Media(js=['djpsite/chat.js'])
home = views.View()
chat = views.View('chat', form=ChatFormHtml, has_plugins=True)
def publish(self, channels, text):
p = pubsub_server(self.settings)
return p.publish(channels, text)
def render(self, request, **kwargs):
return html.Widget('div', cn='chatroom').render(request)
def media(self, request):
return self._media
def render_instance_default(self, request, instance, **kwargs):
mkp = markups.get(instance.markup)
text = instance.body
if mkp:
text = mkp(request, text)
w = Widget('div', text, cn=classes.sitecontent)
if instance.javascript:
g = script_template % instance.javascript
script = g.replace('\r\n', '\n')
if request.is_xhr:
w.add(script)
else:
request.media.add(media.Media(js=[script]))
return w.render(request)
def default_media(self, request):
if not request.is_xhr:
settings = self.settings
m = media.Media(settings=settings)
m.add_js(media.jquery_paths(settings))
m.add_js(media.bootstrap(settings))
m.add_js(settings.DEFAULT_JAVASCRIPT)
if settings.DEFAULT_STYLE_SHEET:
m.add_css(settings.DEFAULT_STYLE_SHEET)
if settings.STYLING:
target = media.site_media_file(settings)
if target:
m.add_css({'all': (target, )})
m.add(self.media(request))
return m
class PageChangeView(views.ChangeView):
'''View for editing a page. It insert an
:class:`djpcms.html.layout.container` at the top of the page with the
editing form.'''
name = 'change'
_media = media.Media(js=['djpcms/rearrange.js'])
edit_container = container(
'edit-page',
cn=classes.edit,
grid_fixed=False,
context_request=lambda r: r,
renderer=lambda r, namespace, col, b: r.render())
def underlying(self, request):
return underlying_response(request, request.instance)
def get_response(self, request):
page = request.instance
layout = page.layout
layout = self.root.get_page_layout(layout)()
# Insert edit page form container
edit_container = layout.maker.child_widget(self.edit_container, layout)
cls = layout.children.__class__
children = cls({edit_container.key: edit_container})
children.update(layout.children)
layout.children = children
return layout
def render(self, request, block=None, **kwargs):
text = super(PageChangeView, self).render(request, block=True)
links = page_links(request)
return box(hd='Editing page {0}'.format(request.instance),
bd=text, collapsed=True, edit_menu=links)\
.addClass(classes.edit)
def defaultredirect(self, request, next=None, instance=None, **kwargs):
if next:
return next
return super(PageChangeView, self).defaultredirect(request,
instance=instance,
**kwargs)
def media(self, request):
return self._media
class BaseTableElement(BaseTable):
'''A :class:`FormLayoutElement` for rendering a group of :class:`Field`
in a table.
:parameter headers: The headers to display in the table.
'''
tag = 'div'
elem_css = "uniFormTable"
_media = media.Media(js=['djpcms/plugins/delete_row.js'])
def __init__(self, headers, *children, **kwargs):
# each row must have the same number of columns as the number of headers
self.headers = [table_header(name) for name in headers]
self.fields = tuple(h.code for h in self.headers)
super(BaseTableElement, self).__init__(*children, **kwargs)
def render_heads(self, request, widget, context):
'''Generator of rendered table heads'''
for head in self.headers:
name = head.code
th = Widget('th', head.name, cn=name, title=head.description)\
.addClass(head.extraclass)
yield th.render(request)
def rows(self, widget):
raise NotImplementedError()
def row_generator(self, request, widget, context):
for row in self.rows(widget):
for tr in row.stream(request, context):
yield tr
def stream(self, request, widget, context):
'''We override inner so that the actual rendering is delegate to
:class:`djpcms.html.Table`.'''
for s in super(BaseTableElement, self).stream(request, widget,
context):
yield s
tr = Widget('tr', self.render_heads(request, widget, context))
head = Widget('thead', tr)
body = Widget('tbody', self.row_generator(request, widget, context))
table = Widget('table', (head, body))
yield table.addClass(self.elem_css).render(request)
class JsTestView(views.View):
_media = media.Media(
js = ['http://code.jquery.com/qunit/git/qunit.js',
'jstests/base.js',
#
'djpcms/plugins/multiselect.js',
'jstests/multiselect.js'],
css = {'screen': ['http://code.jquery.com/qunit/git/qunit.css']})
def linkname(self, request):
return 'js unit'
def title(self, request):
return 'Javascript unit tests'
def render(self, request, **kwargs):
return html
def media(self, request):
return self._media
class FileInputHtml(layout.FieldTemplate):
tag = 'div'
default_class = "fileupload-buttonbar"
_media = media.Media(
js=[
media.jquerytemplate(), 'fileupload/jquery.fileupload.js',
'fileupload/jquery.fileupload-ui.js', 'fileupload/upload.js'
],
css={'screen': ['fileupload/jquery.fileupload-ui.css']})
def stream(self, djp, widget, context):
yield '<label class="fileinput-button">\
<span>Add files...</span>\
{0[inner]}\
</label>\
<button type="submit" class="start">Start upload</button>\
<button type="reset" class="cancel">Cancel upload</button>\
<button type="button" class="delete">Delete files</button>'.format(context)
def media(self, djp=None):
return self._media
class TableMaker(WidgetMaker):
'''A :class:`WidgetMaker` for rendering data tables.'''
tag = 'div'
classes = table_container_class
_media = media.Media(js=[
'djpcms/datatables/jquery.dataTables.js',
'djpcms/datatables/ColVis/js/ColVis.js',
'djpcms/datatables/TableTools/js/TableTools.js', 'djpcms/djptable.js'
], )
def get_context(self, request, widget, context):
# Get the title of the widget (if it has one
title = widget.attrs.get('title')
context = context if context is not None else {}
context.update(widget.internal)
pagination = context.pop('pagination', None)
options = widget.data.get('options')
if options is None:
options = {}
widget.data['options'] = options
if pagination:
options.update({
'bPaginate': True,
'iDisplayLength': pagination['per_page'],
'aLengthMenu': pagination['page_menu']
})
else:
options['bPaginate'] = False
headers = list(self.aoColumns(context['headers']))
widget.data['options']['aoColumns'] = headers
context.update({'headers': headers, 'title': title})
return context
def make_headers(self, headers):
'''Generator of html headers tags'''
for head in headers:
w = Widget('th', cn=head.code)
if head.description:
w.addData('description', head.description)
yield w.render(inner=head.name)
def aoColumns(self, headers):
'''Return an array of column definition to be used by the dataTable
javascript plugin'''
for head in headers:
cn = [head.code]
if head.extraclass:
cn.append(head.extraclass)
so = head.sortable
if so:
cn.append('sortable')
yield {
'bSortable': head.sortable,
'sClass': ' '.join(cn),
'sFilter': head.filter,
'sName': head.code,
'sTitle': head.name,
'sWidth': head.width,
'description': head.description
}
def stream(self, request, widget, context):
title = context.get('title')
head_class = '%s %s' % (classes.widget_head, classes.corner_top)
if title:
# if title is available insert a div containing it
yield "<div class='"+head_class+"'>"\
"<h3 class='table-title'>"+title+"</h3></div>"
footer = context.get('footer')
if footer:
yield '<table>\n<thead>\n<tr>'
else:
yield '<table class="nofooter">\n<thead>\n<tr>'
# Loop over headers
headers = context['headers']
for th in self.headers(headers):
yield th.render(request)
yield '</tr>\n</thead>\n<tbody>'
for row in self.rows(request, widget):
tr = Widget('tr', id=row.get('id'))
for item in row['display']:
tr.add('<td>{0}</td>'.format(item))
yield tr.render(request)
yield '</tbody>'
# footer available
if footer:
yield '<tfoot>\n<tr>'
for th in self.headers(headers):
yield th.render(request)
yield '</tr>\n</tfoot>'
yield '</table>'
def headers(self, headers):
for head in headers:
th = Widget('th', head['sTitle'], title=head['description'])
if head['description']:
th.addClass('hint')
if head['bSortable']:
th.addClass(classes.clickable)
yield th
def rows(self, request, widget):
if widget.data_stream:
headers = widget.internal['headers']
appmodel = widget.internal.get('appmodel')
actions = widget.internal.get('actions')
return (results_for_item(request,
headers,
res,
appmodel,
actions=actions)
for res in widget.data_stream)
else:
return ()
'HtmlEditContentForm'
]
HtmlTemplateForm = forms.HtmlForm(TemplateForm)
HtmlPageForm = forms.HtmlForm(
PageForm,
layout=uni.FormLayout(
uni.Columns(
('doctype', 'layout', 'inner_template', 'grid_system', 'url'),
('title', 'link', 'in_navigation', 'soft_root', uni.SUBMITS))),
inputs=(('save', forms.SAVE_AND_CONTINUE_KEY), ))
ContentBlockHtmlForm = forms.HtmlForm(
ContentBlockForm,
inputs=(('save', forms.SAVE_KEY), ),
layout=uni.FormLayout(
uni.Fieldset('plugin_name', 'container_type', 'title'),
uni.Inlineset('for_not_authenticated'),
html.WidgetMaker(tag='div', key='plugin', cn='form-plugin-container')),
media=media.Media(js=['djpcms/plugins/filters.js']))
HtmlEditContentForm = forms.HtmlForm(
EditContentForm,
layout=uni.FormLayout(
uni.Columns('title', 'markup', uni.SUBMITS),
uni.Tabs(uni.tab('html', uni.Fieldset('body')),
uni.tab('javascript', uni.Fieldset('javascript')),
default_style=uni.nolabel,
tab_type='pills')))
from djpcms import media
from djpcms.cms import request_processor
extra_media = media.Media(css={'all':
[('fontawesome/font-awesome-ie7.css', 'IE 7')]})
@request_processor
def ie_media(request):
request.view.add_media(request, extra_media)
