def render(self, name, value, attrs=None):
if value is None:
value = ''
input_attrs = self.build_attrs(attrs, type=self.input_type, name=name)
if value != '':
# Only add the 'value' attribute if a value is non-empty.
input_attrs['value'] = force_text(self._format_value(value))
input_attrs = dict([(key, conditional_escape(val)) for key, val in input_attrs.items()]) # python2.6 compatible
if not self.picker_id:
self.picker_id = input_attrs.get('id', '') + '_picker'
self.div_attrs['id'] = self.picker_id
picker_id = conditional_escape(self.picker_id)
div_attrs = dict(
[(key, conditional_escape(val)) for key, val in self.div_attrs.items()]) # python2.6 compatible
icon_attrs = dict([(key, conditional_escape(val)) for key, val in self.icon_attrs.items()])
html = self.html_template % dict(div_attrs=flatatt(div_attrs),
input_attrs=flatatt(input_attrs),
icon_attrs=flatatt(icon_attrs))
if self.options:
self.options['language'] = translation.get_language()
js = self.js_template % dict(picker_id=picker_id,
options=json.dumps(self.options or {}))
else:
js = ''
return mark_safe(force_text(html + js))
def render(self, name, value, attrs=None):
tags = value or []
hidden_value = ''
if any(tags):
hidden_value = force_text(",".join(tags))
final_attrs = self.build_attrs(attrs, type=self.input_type, name=name)
final_attrs['autocomplete'] = 'off'
labutils.add_class(final_attrs, TagInput.default_input_class)
id = final_attrs['id']
name = final_attrs['name']
hidden_attrs = {
'type' : 'hidden',
'id' : '%s_hidden' % id,
'name' : '%s_hidden' % name,
'class' : 'cl-tag-hidden',
'value' : hidden_value
}
inputs_html = u"<input%s/><input%s/>" % (flatatt(final_attrs), flatatt(hidden_attrs))
tag_list_html = ""
for tag in tags:
tag_list_html += "<div class='tag'>%s<div class='tag-close'></div></div>" % escape(tag)
inputs_wrap_html = u"<div id='tag_wrap_{0}' class='cl-tag-wrap'>{1}<div id='tag_list_{0}' class='cl-tag-list'>{2}</div></div>".format(id, inputs_html, tag_list_html)
jquery_bootstrap = u"<script>jQuery(function() { jQuery('#tag_wrap_%s').cekolabs_tagwidget() })</script>" % id
return mark_safe(inputs_wrap_html + jquery_bootstrap)
def render(self):
attrs = self.attrs
name = self.name
value = self.value
if (value == 'True'):
value = 1
elif (value == 'False'):
value = 0
else:
value = int(value) if value else False
btn_attrs = attrs.pop('btn_attrs', {})
data_attrs = attrs.pop('data_attrs', {})
btn_container_attrs = attrs.pop('btn_container_attrs', {})
data_container_attrs = attrs.pop('data_container_attrs', {})
btn_container = []
data_container = []
output = []
for (option_value, option_label) in self.choices:
option_label = force_unicode(option_label)
btn = ButtonWidget(attrs=dict(btn_attrs, text=option_label, value=option_value))
rendered_btn = btn.render(attrs=btn_attrs)
btn_container.append(rendered_btn)
if option_value == value:
rb = StoriesServiceInput(attrs=dict(data_attrs, type='radio', name=name, value=option_value, checked='checked'))
else:
rb = StoriesServiceInput(attrs=dict(data_attrs, type='radio', name=name, value=option_value))
rendered_rb = rb.render(name, value)
data_container.append(rendered_rb)
btn = '<div%s>%s</div>' % (flatatt(btn_container_attrs), join(btn_container))
data = '<div%s>%s</div>' % (flatatt(data_container_attrs), join(data_container))
output.append(btn)
output.append(data)
return mark_safe(u'\n'.join(output))
def render(self, name, value, attrs=None):
if value is None:
value = ''
input_attrs = self.build_attrs(attrs, type=self.input_type, name=name)
if value != '':
# Only add the 'value' attribute if a value is non-empty.
# Issue#28
if isinstance(value, datetime.time):
value = datetime.datetime(2014, 11, 25, value.hour, value.minute, value.second) # any date with value time
input_attrs['value'] = force_text(self._format_value(value))
input_attrs = dict([(key, conditional_escape(val)) for key, val in input_attrs.items()]) # python2.6 compatible
if not self.picker_id:
self.picker_id = input_attrs.get('id', '') + '' if self.hide_div else '_picker'
self.div_attrs['id'] = self.picker_id
picker_id = conditional_escape(self.picker_id)
div_attrs = dict(
[(key, conditional_escape(val)) for key, val in self.div_attrs.items()]) # python2.6 compatible
icon_attrs = dict([(key, conditional_escape(val)) for key, val in self.icon_attrs.items()])
html = self.html_template % dict(input_attrs=flatatt(input_attrs))
if not self.hide_icon:
html += self.button_template % dict(icon_attrs=flatatt(icon_attrs))
if not self.hide_div:
html = self.div_template % dict(div_attrs=flatatt(div_attrs), content=html)
# html = self.html_template % dict(div_attrs=flatatt(div_attrs),
# input_attrs=flatatt(input_attrs),
# icon_attrs=flatatt(icon_attrs))
if not self.options:
js = ''
else:
js = self.js_template % dict(picker_id=picker_id,
options=json.dumps(self.options or {}))
return mark_safe(force_text(html + js))
def render(self, name, value, attrs=None):
"""
Figures out whether it is a widget for a textarea or for an input.
"""
if value is None:
value = ''
final_attrs = self.build_attrs(attrs, type=self.input_type, name=name)
if value != '':
final_attrs['value'] = force_unicode(self._format_value(value))
maxlength = final_attrs.get('maxlength',False)
if not maxlength:
return mark_safe(u'<input%s />'%flatatt(final_attrs))
current = force_unicode(int(maxlength) - len(value))
html = u"""
<span class="charsleft charsleft-input">
<input %(attrs)s />
<span><span class="count">%(current)s</span> characters remaining</span>
<span class="maxlength">%(maxlength)s</span>
</span>
""" % {
'attrs':flatatt(final_attrs),
'current':current,
'maxlength':int(maxlength),
}
return mark_safe(html)
def render(self, name, value, attrs=None, hattrs=None, initial_objects=u''):
if value is None:
value = ''
classes = {}
lookup = ''
if self.settings.field and self.settings.field.rel:
if self.js_options['multiple']:
classes['class'] = 'vManyToManyRawIdAdminField'
hidden_id = attrs.pop('id', 'id_%s' % name)
attrs['id'] = 'id_ac_%s' % name
if self.settings.lookup:
related_url = '%s%s/%s/' % (reverse('admin:index'),
self.settings.field.rel.to._meta.app_label,
self.settings.field.rel.to._meta.object_name.lower())
params = self.url_parameters()
if params:
url = '?' + '&'.join(['%s=%s' % (k, v) for k, v in params.items()])
else:
url = ''
lookup = (u'<a href="%s%s" class="related-lookup" id="lookup_id_%s" '
u'onclick="return showRelatedObjectLookupPopup(this);"> '
u'<img src="%sselector-search.gif" width="16" height="16" alt="%s" />'
u'</a>' % (related_url, url, name, ADMIN_URL, _('Lookup')))
else:
hidden_id = 'id_hidden_%s' % name
hidden_attrs = self.build_attrs(classes, type='hidden', name=name, value=value, id=hidden_id)
if self.script_tag:
normal_attrs = self.build_attrs(attrs, type='text')
else:
data_options = dict([('data-%s' % format_js_data(key),
JS_VALUE_MAPPING.get(option, option))
for key, option in self.js_options.items()])
normal_attrs = self.build_attrs(attrs, type='text', name=name, **data_options)
normal_attrs['class'] = 'dj-ac'
if value:
if self.settings.reverse_label:
normal_attrs['value'] = self.label_for_value(value)
else:
normal_attrs['value'] = value
if not self.js_options.get('source'):
self.js_options['source'] = self.settings.get_absolute_url()
options = simplejson.dumps(self.js_options)
if self.script_tag:
return mark_safe(u''.join((
u'<input%s />\n' % flatatt(hidden_attrs),
u'<input%s />\n' % flatatt(normal_attrs),
lookup,
initial_objects,
u'<script type="text/javascript">',
u'django.autocomplete("#%s", %s);' % (attrs['id'], options),
u'</script>\n',
)))
else:
return mark_safe(u''.join((
u'<input%s />\n' % flatatt(normal_attrs),
lookup,
)))
def render(self, name, value, attrs=None):
if value is None:
value = ''
input_attrs = self.build_attrs(attrs, type=self.input_type, name=name)
if value != '':
# Only add the 'value' attribute if a value is non-empty.
input_attrs['value'] = force_text(self._format_value(value))
input_attrs = dict([(key, conditional_escape(val)) for key, val in input_attrs.items()]) # python2.6 compatible
if not self.picker_id:
self.picker_id = input_attrs.get('id', '') + '_picker'
self.div_attrs['id'] = self.picker_id
picker_id = conditional_escape(self.picker_id)
div_attrs = dict([(key, conditional_escape(val)) for key, val in self.div_attrs.items()]) # python2.6 compatible
html = '''
<div%(div_attrs)s>
<input%(input_attrs)s/>
<span class="input-group-addon">
<span class="glyphicon glyphicon-calendar"></span>
</span>
</div>''' % dict(div_attrs=flatatt(div_attrs),
input_attrs=flatatt(input_attrs))
if self.options == False:
js = ''
else:
js = '''
<script>
$(function() {
$("#%(picker_id)s").datetimepicker(%(options)s);
});
</script>''' % dict(picker_id=picker_id,
options=json.dumps(self.options or {}))
return mark_safe(force_text(html + js))
def render(self, name, value, attrs=None):
if value is None:
value = u''
span_attrs = merge_html_attrs(self.attrs, attrs, contenteditable=u'true', class_=u'editable-span')
input_attrs = dict(type=u'hidden', name=name, value=force_text(value))
return format_html(u'<span{0}>{1}</span><input{2} />',
flatatt(span_attrs), force_text(value), flatatt(input_attrs))
def render(self, name, value, attrs=None):
# Render actual input tag - an <input type="hidden">
# which will be manipulated via JS.
input_tag = super(MediaPopupWidget, self).render(name, value, attrs)
try:
value = FileNode.objects.get(pk=value)
selected_title = value.file.name
except FileNode.DoesNotExist:
value = None
selected_title = None
media_title = format_html("<strong>{0}</strong>", selected_title)
url = reverse('admin:media_tree_filenode_changelist')
btn_attrs = {'href': url + self.for_param,
'class': 'mediatree-btn-select',
'id': attrs['id'] + '-select'}
button_select = format_html(BTN, flatatt(btn_attrs), _("Select media"))
url = reverse('admin:media_tree_filenode_add')
btn_attrs = {'href': url + self.for_param,
'class': 'mediatree-btn-upload',
'id': attrs['id'] + '-upload'}
button_upload = format_html(BTN, flatatt(btn_attrs), _("Upload media"))
return format_html(
WIDGET, input_tag, media_title, button_select, button_upload)
def render(self, name, value, attrs=None, choices=()):
if value is None: value = ''
final_attrs = self.build_attrs(attrs, name=name)
output = [u'<select%s>' % flatatt(final_attrs)]
options = self.render_options(choices, [value])
if options:
output.append(options)
output.append(u'</select>')
output.append(u'</div>')
picker_id = conditional_escape(self.attrs['id'])
div_attrs = dict([(key, conditional_escape(val)) for key, val in self.div_attrs.items()]) # python2.6 compatible
icon_attrs = dict([(key, conditional_escape(val)) for key, val in self.icon_attrs.items()])
html = self.html_template % dict(div_attrs=flatatt(div_attrs),
icon_attrs=flatatt(icon_attrs))
html += u'\n'.join(output)
if self.options:
#self.options['language'] = translation.get_language()
js = self.js_template % dict(picker_id=picker_id,
options=json.dumps(self.options or {}))
else:
js = ''
#return mark_safe(u'\n'.join(output))
return mark_safe(force_text(html + js))
def render(self, name, value, attrs=None):
final_attrs = self.build_attrs(attrs, type=self.input_type, name=name)
hidden_atts = final_attrs.copy()
hidden_atts.update(type='hidden', value='--remove--', disabled='disabled')
attrs = final_attrs.copy()
attrs.update(image_url=self.image_url,
height=self.height,
flat_atts=flatatt(final_attrs),
hidden_atts=flatatt(hidden_atts),
rand=time.time())
if self.image_url and value and value != self.initial:
return mark_safe(u'''
<div id="dbfi_%(id)s" class="dbfi">
<div class="dbfi_display">
<span id="dbfi_%(id)s_show" class="dbfi_action"><img src="%(image_url)s?rand=%(rand)s" height="%(height)s" alt="Image"/></span>
<span id="dbfi_%(id)s_change" class="dbfi_action" style="display:none;"><input%(flat_atts)s /></span>
<span id="dbfi_%(id)s_delete" class="dbfi_action" style="display:none;"><span style="background-color: lightyellow; padding: 3px;">Your image will be removed on submit.</span><input%(hidden_atts)s /></span>
</div>
<div class="dbfi_choices">
<a href="#dbfi_%(id)s_change">Change</a> | <a href="#dbfi_%(id)s_delete">Delete</a>
</div>
<div class="dbfi_cancel" style="display:none;">
<a href="#dbfi_%(id)s_show">Cancel</a>
</div>
</div>
''' % attrs)
return super(ExistingImageWidget, self).render(name, None, attrs=attrs)
def render(self, name, value, attrs=None):
if value is None:
value = []
else:
value = json.loads(value)
#import pdb;pdb.set_trace()
html = "<br />"
for prestacion_obj in Prestacion.objects.all():
html += "<br /><h3>%s</h3><br />" % prestacion_obj.titulo
for prestacion in prestacion_obj.prestaciones.split('\r\n'):
if not prestacion:
continue
att = {'type': "checkbox",
'value': prestacion,
'data-hidden-id': attrs['id'],}
if prestacion in value:
att['checked'] = 'checked'
html += "<input %s onchange=togglePrestacion(this) /> %s" % (flatatt(att), prestacion)
html += "<br />"
attrs['name'] = name
attrs['type'] = 'hidden'
html = "<input %s value=\"%s\" /> %s" % (flatatt(attrs), escape(json.dumps(value)), html)
html = """
<script type=\"text/javascript\" src=\"/static/js/admin.js\"></script>
%s
""" % html
return format_html(html)
def render(self, name, value, attrs=None, choices=()):
if self.attrs is None:
attrs = {}
else:
attrs = self.attrs
if value is None:
value = ''
display_value = ''
for k, v in self.choices:
if k == value:
display_value = v
classname = '%s %s' % (self.attrs['class'], 'chained') if 'class' in self.attrs else 'chained'
display_attrs = dict(self.display_settings, **{
'id': 'id_%s_display' % name,
'data-hidden-id': 'id_%s' % name,
'class': classname,
'value': display_value,
})
hidden_attrs = dict(self.hidden_settings, **{
'id':'id_%s' % name,
'name': name,
'value': value,
'class': 'chained'
})
return render_to_string('form/widgets/chained_text_widget.html', {
'display_attrs': flatatt(display_attrs),
'attrs': flatatt(hidden_attrs),
'display_value': display_value
})
def render(self, name, value, attrs=None, choices=()):
if value is None:
value = ''
# insert a nice bit of javascript to show the flag of the country
# selected
# TODO check that attrs['id'] is set?
output = [ '''\
<script type="text/javascript">
jQuery(function(){
FlagSelect.init("%(id)s", "%(media)s");
});
</script>
''' % {
'id': attrs ['id'],
'media': settings.MEDIA_URL,
}]
span_attrs = self.build_attrs(attrs)
select_attrs = self.build_attrs(name=name)
output.append(u'<span%s><select%s>' % (flatatt(span_attrs), flatatt(select_attrs)))
options = self.render_options(choices, [value])
if options:
output.append(options)
output.append('</select></span>')
return mark_safe(u'\n'.join(output))
def render(self, name, value, attrs=None, choices=()):
if value is None: value = []
final_attrs = self.build_attrs(attrs, name=name)
# Pop id
id = final_attrs['id']
del final_attrs['id']
# Insert blank value
choices = [('','---')] + list(self.choices)
# Build values
items = []
for val in value:
opts = "\n".join([TPL_OPTION %{'value': k, 'desc': v, 'selected': val == k and 'selected="selected"' or ''} for k, v in choices])
items.append(TPL_SELECT %{'attrs': flatatt(final_attrs), 'opts': opts})
# Build blank value
opts = "\n".join([TPL_OPTION %{'value': k, 'desc': v, 'selected': ''} for k, v in choices])
items.append(TPL_SELECT %{'attrs': flatatt(final_attrs), 'opts': opts})
script = TPL_SCRIPT %{'id': id}
output = TPL_FULL %{'id': id, 'values': '\n'.join(items), 'script': script}
return mark_safe(output)
def render(self, name, value, attrs=None):
if value is None: value = ''
widget_attrs = self.build_attrs(attrs)
hidden_attrs = {'id':attrs['id'], 'name':name}
if value != '':
# Only add the 'value' attribute if a value is non-empty.
widget_attrs['value'] = force_unicode(self.model.objects.get(pk=value))
hidden_attrs['value'] = force_unicode(value)
widget_attrs['id'] = 'widget_' + attrs['id']
return mark_safe(u'''
<div class="autocomplete">
<input type="text"%(widget_attrs)s />
<input type="hidden"%(hidden_attrs)s />
<script type="text/javascript">
$('#%(widget_id)s').james('%(url)s', {%(options)s,
params: 'limit=%(limit)s',
onSelect: function(data, json) {
$('#%(hidden_id)s').val(json.pk);
return data;
}
});
</script>
</div>
''' % {
'widget_attrs':flatatt(widget_attrs),
'hidden_attrs':flatatt(hidden_attrs),
'widget_id':widget_attrs['id'],
'hidden_id':hidden_attrs['id'],
'url':self.url, 'options': plist_from_dict(self.options),
'limit':self.limit,
})
def render(self, name, value, attrs=None, choices=()):
if value is None:
value = ''
final_attrs = self.build_attrs(attrs, type='hidden', name=name)
if value != '':
# Only add the 'value' attribute if a value is non-empty.
final_attrs['value'] = force_unicode(self._format_value(value))
hidden = u'<input%s />' % flatatt(final_attrs)
final_attrs['type'] = 'text'
final_attrs['id'] += '_ac'
del final_attrs['name']
try:
model = self.choices.queryset.get(pk=value)
final_attrs['value'] = force_unicode(model)
except (self.choices.queryset.model.DoesNotExist, ValueError, TypeError):
final_attrs['value'] = u''
if self.is_required:
ac = u'<input%s />' % flatatt(final_attrs)
else:
final_attrs['class'] = final_attrs.get('class', '') + ' ac_nullable'
ac = (u' <a href="#" id="%(id)s_cl" class="ac_clear"> %(text)s</a>' % {
'id': final_attrs['id'][:-3],
'text': _('clear'),
}) + (u'<input%s />' % flatatt(final_attrs))
js = u'''<script type="text/javascript">
$(function() {
$('#%(id)s_ac').autocomplete({
source: %(source)s,
minLength: 2,
focus: function(event, ui) {
$('#%(id)s_ac').val(ui.item.label);
return false;
},
select: function(event, ui) {
$('#%(id)s').val(ui.item.value).trigger('change');
$('#%(id)s_ac').val(ui.item.label);
return false;
}
}).bind('focus', function() {
this.select();
}).bind('blur', function() {
if (!this.value)
$('#%(id)s').val('');
});
$('#%(id)s_cl').click(function(){
$('#%(id)s, #%(id)s_ac').val('');
return false;
});
});
</script>
''' % {'id': attrs.get('id', name), 'name': name, 'source': self._source()}
return mark_safe(hidden + ac + js)
def test_flatatt(self):
###########
# flatatt #
###########
self.assertEqual(flatatt({'id': "header"}), ' id="header"')
self.assertEqual(flatatt({'class': "news", 'title': "Read this"}), ' class="news" title="Read this"')
self.assertEqual(flatatt({}), '')
def render(self, name, node, attrs=None):
if not attrs:
attrs = {}
final_attrs = self.build_attrs(attrs)
if self.form:
if hasattr(self.form, 'render'):
return self.form.render()
return mark_safe(u'<table%s>%s</table>' % (flatatt(final_attrs), self.form.as_table()))
return mark_safe(u'<table%s> </table>' % flatatt(final_attrs))
def render(self, name, value=None, attrs=None):
"""
The widget consists of two text fields:
1. Field with id = "id_<field_name>_text", which holds the text values
2. Field with id = "id_<field_name>", which is hidden and holds the pk
of a selected item.
"""
text_field_attrs = self.build_attrs(attrs, name=name + "_text")
# if there is any initial value available, fill the text field from the queryset
text_field_value = ""
if value:
func = get_installed("%(app)s.ajax.%(func)s" % {
'app': self.app,
'func': self.qs_function,
})
queryset = func("all")
try:
obj = queryset.get(pk=value)
text_field_value = getattr(obj, self.display_attr)
if callable(text_field_value) and not getattr(text_field_value, "alters_data", False):
text_field_value = text_field_value()
except:
pass
text_field_attrs['value'] = text_field_value
text_field_attrs['class'] = "autocomplete textinput textInput form-control"
if not self.attrs.has_key('id'):
text_field_attrs['id'] = 'id_%s_text' % name
# hidden field for key value
hidden_field_attrs = {
'id' : 'id_%s' % name,
'name' : '%s' % name,
'value' : value or "",
'class' : "form_hidden",
}
return mark_safe(
u"""
<input type="text" %(text_field_attrs)s/>
<input type="hidden" %(hidden_field_attrs)s />
<script type="text/javascript">
/* <![CDATA[ */
%(js)s
/* ]]> */
</script>""" % {
'text_field_attrs' : flatatt(text_field_attrs),
'js' : self.render_js(
hidden_field_attrs['id'],
text_field_attrs['id'],
text_field_value,
),
'hidden_field_attrs' : flatatt(hidden_field_attrs),
}
)
def render(self, name, value, attrs=None):
final_attrs = self.build_attrs(attrs)
final_attrs['class'] = ' '.join(final_attrs.get('class', u'').split() + ['model-link'])
if self.object:
return mark_safe(u'<a target="_blank" %s href="../../../%s/%s/%s/">%s</a>' %
(flatatt(final_attrs), self.object._meta.app_label,
self.object._meta.object_name.lower(), self.object.pk, self.object))
else:
return mark_safe(u'<span %s>nie wybrano</span>' % flatatt(final_attrs))
def render(self, name, value, attrs=None):
if isinstance(value, list):
chbx = value[0]
taxo = value[1]
else:
(chbx, taxo) = self.decompress(value)
taxo_attrs = self.build_attrs(attrs, name=name + '_1', type='text')
taxo_attrs['id'] = 'id_' + name + '_1'
chbx_attrs = {'id': 'id_' + name + '_0', 'name': name + '_0',
'style': 'vertical-align: text-bottom;',
'type': 'checkbox'}
if chbx:
chbx_attrs['checked'] = ''
# Only add the 'value' attribute if a value is non-empty.
taxo_attrs['value'] = force_text(self._format_value(taxo))
return format_html(r'''
<span id="id_{3}_cbox"><span style="vertical-align: text-bottom;">Any:</span>
<input {0} type="checkbox"
onClick="
if (this.checked) {{
var nam = '{3}' + '_1';
$('[name = ' + nam + ']').val('');
}}
taxonomy_update();
"/></span>
<input {1}
onfocus="
if ($('#id_taxonomy_type').val() == 1) {{
$('#id_{3}_cbox').css('visibility', 'visible');
$('#id_{3}_taxtweb').css('visibility', 'visible');
}}
else {{
$('#id_{3}_cbox').css('visibility', 'hidden');
$('#id_{3}_taxtweb').css('visibility', 'hidden');
}}"
onblur="
$('[name={3}_0]').prop('checked', this.value == '');
taxonomy_update();"
onchange="
$('[name={3}_0]').prop('checked', this.value == '');
taxonomy_update();"
/>
<a id="id_{3}_taxtweb" style="font-size: 16px;
font-weight: bold;" href="#" onclick="var pu_win = window.open('''
''''/taxtweb/{2}?is_popup=yes', '_blank', 'scrollbars=no,resizable=yes, width=800,'''
''' height=800, status=no, location=no, toolbar=no');">TaxTweb</a>''',
flatatt(chbx_attrs), flatatt(taxo_attrs),
force_text(self._format_value(taxo)), name)
def render(self, name, value, attrs=None):
if value is None:
value = ''
final_attrs = self.build_attrs(attrs, type=self.input_type, name=name)
if value != '':
# Only add the 'value' attribute if a value is non-empty.
final_attrs['value'] = force_unicode(self._format_value(value))
if self.measure:
return mark_safe(u'<input%s /> %s' % (flatatt(final_attrs),self.measure))
return mark_safe(u'<input%s />' % flatatt(final_attrs))
def render(self, name, value, attrs=None):
if value is None:
value = u''
# Workaround for Safari 7: If ``data-padding`` attribute is set in javascript only, Safari
# 7 ignores it until the span is clicked. So the span is invisible if it is empty.
# Therefore we must set it here as well.
span_attrs = merge_html_attrs(self.attrs, attrs, {'data-padding': '. '*47},
contenteditable=u'true', class_=u'pln-editable-span')
input_attrs = dict(type=u'hidden', name=name, value=force_text(value))
return format_html(u'<span{0}>{1}</span><input{2} />',
flatatt(span_attrs), force_text(value), flatatt(input_attrs))
def render(self, name, value, attrs=None, choices=()):
final_attrs = self.build_attrs(attrs, name=name)
if isinstance(value, models.Model):
output = ['<input type="text" %s value="%s"/>'
%(flatatt(final_attrs), getattr(value, self.fk_field_name))]
else:
output = ['<input type="text" %s/>'%flatatt(final_attrs)]
options = self.render_options(choices, value, attrs['id'], name)
output.append(options)
return mark_safe(u'\n'.join(output))
def render(self, name, value, attrs=None):
attrs = attrs or self.attrs
parent_attrs = {
"class": "wed-widget-parent",
}
wed_attrs = {
"class": "wed-widget loading container",
"style": "display: none",
"id": attrs['id']
}
return mark_safe('<div%s><div>Loading...</div><div%s>%s</div></div>' %
(flatatt(parent_attrs), flatatt(wed_attrs), value))
def render(self, name, value=None, attrs=None, prelabel=None):
self.attrs.update(attrs or {})
final_attrs = self.build_attrs(self.attrs, name=name)
prelabel = prelabel or self.prelabel
if prelabel:
out = u'<label for="%s" >%s</label><input type="checkbox"%s >' \
% (self.attrs.get("id", ""), value or self.label,
flatatt(final_attrs))
else:
out = u'<input type="checkbox"%s ><label for="%s" >%s</label>' \
% (flatatt(final_attrs), self.attrs.get("id", ""),
value or self.label)
return mark_safe(out)
def render(self, name, value, attrs=None):
if value is None:
value = ''
value = force_unicode(value)
final_attrs = self.build_attrs(attrs, name=name)
textarea_output = mark_safe(u'<textarea%s>%s</textarea>'
% (flatatt(final_attrs),
conditional_escape(force_unicode(value))))
geometry_context = Context({'geometry_field_id': final_attrs.get('id'),
'geometry_attrs': mark_safe(flatatt(self.attrs)),
'geometry_update_address_field': self.update_address_field})
geometry_template = Template(GEOMETRY_TEMPLATE)
geometry_output = mark_safe(geometry_template.render(geometry_context))
return mark_safe(u"%s%s" % (textarea_output, geometry_output))
def render(self, name, value, attrs=None):
final_attrs = self.build_attrs(attrs, name=name)
if not value:
render = """
<link rel="stylesheet" type="text/css" href="%(media_url)scss/cupertino/ui.all.css" />
<div%(attrs)s></div><div id="dateselected_%(div_id)s"></div>
<script type="text/javascript">
$("#%(div_id)s").datepicker({
dateFormat: 'yy-mm-dd',
onSelect: function(date, instance) {
$("#dateselected_%(div_id)s").html("<input type='hidden' name='%(name)s' value='"+ date +" 12:00'/>");
}
});
</script>
""" % {
'media_url': settings.MEDIA_URL,
'attrs': flatatt(final_attrs),
'div_id': final_attrs['id'],
'name': final_attrs['name'],
}
else:
if isinstance(value, unicode) or isinstance(value, str):
if value.find(":") > 0:
value = datetime.datetime.strptime(value, "%Y-%m-%d %H:%M")
else:
value = datetime.datetime.strptime(value, "%Y-%m-%d")
render = """
<link rel="stylesheet" type="text/css" href="%(media_url)scss/cupertino/ui.all.css" />
<div%(attrs)s></div><div id="dateselected_%(div_id)s"></div>
<script type="text/javascript">
$("#%(div_id)s").datepicker({
dateFormat: 'yy-mm-dd',
onSelect: function(date, instance) {
$("#dateselected_%(div_id)s").html("<input type='hidden' name='%(name)s' value='"+ date +" 12:00'/>");
}
});
$("#%(div_id)s").datepicker("setDate", new Date(%(year)d,%(monthzerobased)02d,%(day)02d));
$("#dateselected_%(div_id)s").html("<input type='hidden' name='%(name)s' value='%(year)d-%(month)02d-%(day)02d 12:00'/>");
</script>
""" % {
'media_url': settings.MEDIA_URL,
'attrs': flatatt(final_attrs),
'div_id': final_attrs['id'],
'name': final_attrs['name'],
'year': value.year,
'monthzerobased': value.month-1,
'month': value.month,
'day': value.day,
}
return render
def render(self, name, value, attrs=None):
if value is None: return u''
final_attrs = self.build_attrs(attrs, name=name)
# output input-hidden together with <iframe>
# this is necessary to keep the ForeignKey relationship intact
input_hidden_attrs = self.build_attrs(attrs, name=name, style='', width='')
if value != '':
input_hidden_attrs['value'] = force_unicode(value)
return mark_safe(u'<input type="hidden" %s /><iframe src="%s" %s></iframe>' % (
flatatt(input_hidden_attrs),
conditional_escape(force_unicode(reverse("form_entry_edit", args=[value,]))),
flatatt(final_attrs),
))
def render(self, name, value, attrs=None):
if value is None:
value = ''
final_attrs = self.build_attrs(attrs, name=name)
final_attrs['class'] = 'nav nav-pills nav-stacked'
output = [u'<ul%s>' % flatatt(final_attrs)]
options = self.render_options(force_unicode(value), final_attrs['id'])
if options:
output.append(options)
output.append(u'</ul>')
output.append(
'<input type="hidden" id="%s_input" name="%s" value="%s"/>' %
(final_attrs['id'], name, force_unicode(value)))
return mark_safe(u'\n'.join(output))
def tag(self):
if 'id' in self.attrs:
self.attrs['id'] = '%s_%s' % (self.attrs['id'], self.index)
if 'ng-model' in self.attrs:
self.attrs['ng-model'] = '%s.%s' % (self.attrs['ng-model'],
self.choice_value)
name = '%s.%s' % (self.name, self.choice_value)
final_attrs = dict(self.attrs,
type=self.input_type,
name=name,
value=self.choice_value)
if self.is_checked():
final_attrs['checked'] = 'checked'
return format_html('<input{0} />', flatatt(final_attrs))
def render(self, name, value, attrs={}):
if value is None: value = ''
final_attrs = self.build_attrs(attrs, name=name)
final_id = final_attrs['id'].replace('-', '_')
del final_attrs['id']
return mark_safe(
render_to_string(
self.template, {
'final_attrs': flatatt(final_attrs),
'value': conditional_escape(force_text(value)),
'id': final_id,
'server_side_preview':
settings.PAGEDOWN_SERVER_SIDE_PREVIEW,
}))
def render(self, name, value, attrs=None, choices=()):
if value is None: value = []
if attrs:
attrs['class'] = attrs.get('class', '') + ' admin-tree'
else:
attrs['class'] = 'admin-tree'
final_attrs = self.build_attrs(attrs, name=name)
output = [u'<div%s>' % flatatt(final_attrs)]
# Normalize to strings
str_values = set([force_unicode(v) for v in value])
self.fill_output(output, self.choices, str_values)
output.append(u'</div>')
return mark_safe(u'\n'.join(output))
def render(self, name, value, attrs=None):
widget_attrs = self.build_widget_attrs(name)
attrs = self.build_attrs(attrs)
self.html_id = attrs.pop('id', name)
autocomplete = self.autocomplete(values=value)
choices = autocomplete.choices_for_values()
values = [autocomplete.choice_value(c) for c in choices]
context = {
'name': name,
'values': values,
'choices': choices,
'widget': self,
'attrs': safestring.mark_safe(flatatt(attrs)),
'widget_attrs': safestring.mark_safe(flatatt(widget_attrs)),
'autocomplete': autocomplete,
}
context.update(self.extra_context)
template = getattr(autocomplete, 'widget_template',
self.widget_template)
return safestring.mark_safe(render_to_string(template, context))
def render(self, name, value, attrs=None):
if value is None:
value = []
final_attrs = self.build_attrs(attrs)
self.html_id = final_attrs.pop('id', name)
lookup = get_lookup(self.channel)
# eg. value = [3002L, 1194L]
if value:
current_ids = "|" + "|".join(
str(pk) for pk in value) + "|" # |pk|pk| of current
else:
current_ids = "|"
objects = lookup.get_objects(value)
# text repr of currently selected items
initial = []
for obj in objects:
display = lookup.format_item_display(obj)
initial.append([display, obj.pk])
if self.show_help_text:
help_text = self.help_text
else:
help_text = u''
context = {
'name': name,
'html_id': self.html_id,
'current': value,
'current_ids': current_ids,
'current_reprs': mark_safe(simplejson.dumps(initial)),
'help_text': help_text,
'extra_attrs': mark_safe(flatatt(final_attrs)),
'func_slug': self.html_id.replace("-", ""),
'add_link': self.add_link,
}
context.update(
plugin_options(lookup, self.channel, self.plugin_options, initial))
context.update(bootstrap())
return mark_safe(
render_to_string(
('autocompleteselectmultiple_%s.html' % self.channel,
'autocompleteselectmultiple.html'), context))
def render(self, name, data, attrs=None):
from mysite.personnel.views import get_dept_tree_data
from django.core.urlresolvers import reverse
#print "ZDeptChoiceWidget_render data", data
if data is not None:
try:
data = int(data)
except:
pass
if type(data) in (int, long):
data = self.choices.queryset.model.objects.get(pk=data)
if attrs: self.attrs.update(attrs)
if 'id' not in self.attrs: self.attrs['id'] = 'id_' + name
self.attrs['class'] = self.attrs['class'] + ' filetree r'
self.attrs = self.build_attrs(self.attrs, name=name)
required = ""
if hasattr(self.choices.field,
"required") and self.choices.field.required:
required = "class='wZBaseCharField required input_showDeptTree'"
try:
vdata = filterdata_by_user(self.choices.queryset.all(),
threadlocals.get_current_user())
for ii in vdata:
if ii.parent_id is not None:
l = [e for e in vdata if e.id == ii.parent_id]
if not l: ii.parent_id = None
html = DeptTree(vdata).html_ul_li(data and [data.pk] or [])
html_el = {
"disp": data or "",
"name": name,
"value": data and data.pk or "",
"attr": flatatt(self.attrs),
"required": required,
"id": self.attrs['id'],
"uid": "%s" % id(self),
"none": _(u"撤销选择").capitalize(),
"items": html,
"ok": _(u"确定")
}
if self.flat == False: #平铺
return ('<input %(required)s class="wZBaseCharField input_showDeptTree" type="text" readonly="readonly" value="%(disp)s"><input type=hidden name="%(name)s" value="%(value)s">'+\
u'<span class="btn_showDeptTree"><img onclick="render_dept_dropdown(this, false)" src="/media/img/sug_down_on.gif" id="id_drop_dept"><div id="show_deptment" style="display: none;"><div class="title"><span class="span_selectNone Link_blue1" onclick="dept_tree_none(this)"><a href="javascript: void(0)">%(none)s</a> </span><span onclick="javascript:$(this).parent().parent().hide();" class="close btn">%(ok)s</span></div><div id="id_dept"><ul %(attr)s>%(items)s</ul></div></div></span>')%html_el
else:
return u'<input type=hidden><input value="%(disp)s" type=hidden>%(value)s<div id="show_deptment"><div id=%(uid)s><ul %(attr)s>%(items)s</ul></div><script>render_dept_($("#%(uid)s"),false,true)</script></div>' % html_el
except:
print_exc()
def render(self, name, value, attrs=None):
if value is None:
value = ''
input_attrs = self.build_attrs(attrs, type=self.input_type, name=name)
if value != '':
# Only add the 'value' attribute if a value is non-empty.
input_attrs['value'] = force_text(self._format_value(value))
input_attrs = dict([(key, conditional_escape(val)) for key, val in input_attrs.items()]) # python2.6 compatible
if not self.picker_id:
self.picker_id = input_attrs.get('id', '') + '_picker'
self.div_attrs['id'] = self.picker_id
picker_id = conditional_escape(self.picker_id)
div_attrs = dict(
[(key, conditional_escape(val)) for key, val in self.div_attrs.items()]) # python2.6 compatible
icon_attrs = dict([(key, conditional_escape(val)) for key, val in self.icon_attrs.items()])
html = self.html_template % dict(div_attrs=flatatt(div_attrs),
input_attrs=flatatt(input_attrs),
icon_attrs=flatatt(icon_attrs))
if not self.options:
js = ''
else:
js = self.js_template % dict(picker_id=picker_id,
options=json.dumps(self.options or {}))
return mark_safe(force_text(html + js))
def render(self, name, value, attrs=None):
readonly_attrs = {
'id': 'tos-content',
}
if self.tos_text:
text = mark_safe(
u'<div id="tos-readonly-%s"><div %s>%s</div></div>' % (
name, flatatt(readonly_attrs),
conditional_escape(mark_safe(force_unicode(self.tos_text)))))
else:
text = mark_safe(
u'<div id="tos-readonly-%s">Terms of Agreement content is not set.</div>')
checkbox = super(TOSWidget, self).render(name, value, attrs)
return mark_safe(u'%s%s' % (text, checkbox))
def render(self, name, value, attrs=None):
final_attrs = self.build_attrs(attrs, type='text', name=name)
if not type(value) == unicode and value is not None:
out_vals = []
for val in value:
try:
out_vals.append(str(User.objects.get(pk=val).username))
except:
continue
value = ', '.join(out_vals)
if value:
final_attrs['value'] = smart_str(value)
else:
final_attrs['value'] = smart_str(value)
return mark_safe(u'<input%s />' % flatatt(final_attrs))
def attr_string(self):
"""
Returns a flattened string of HTML attributes based on the
``attrs`` dict provided to the class.
"""
final_attrs = copy.copy(self.attrs)
# Handle css class concatenation
default = " ".join(getattr(settings,
"ACTION_CSS_CLASSES",
ACTION_CSS_CLASSES))
defined = self.attrs.get('class', '')
additional = " ".join(self.classes)
final_classes = " ".join((defined, default, additional)).strip()
final_attrs.update({'class': final_classes})
return flatatt(final_attrs)
def render(self, name, value, attrs={}):
if value is None:
value = ''
final_attrs = self.build_attrs(attrs, name=name)
self.config['container'] = "%s_epiceditor" % (final_attrs['id'], )
self.config['textarea'] = final_attrs['id']
return mark_safe(
render_to_string(
'epiced/widget.html', {
'final_attrs': flatatt(final_attrs),
'parser': self.config['parser'],
'field_id': final_attrs['id'],
'value': conditional_escape(force_unicode(value)),
'config': json.JSONEncoder().encode(self.config)
}))
def format_output(self, attrs, rendered_widgets):
"""
This output will yeild all widgets grouped in a un-ordered list
"""
final_attrs = self.build_attrs(attrs)
id_ = final_attrs.get('id', None)
ret = ['<ul class="formfield" %s>' % flatatt(final_attrs)]
for i, field in enumerate(self.fields.values()):
label = self.format_label(field, id_, i)
help_text = self.format_help_text(field, i)
ret.append('<li>%s %s %s</li>' %
(label, rendered_widgets[i], help_text))
ret.append('</ul>')
return u''.join(ret)
def render(self, name, value, attrs=None):
if value is None:
value = []
attrs = self.attrs
btn_attrs = attrs.pop('btn_attrs', {})
data_attrs = attrs.pop('data_attrs', {})
btn_container_attrs = attrs.pop('btn_container_attrs', {})
data_container_attrs = attrs.pop('data_container_attrs', {})
btn_container = []
data_container = []
output = []
for (option_value, option_label) in self.choices:
option_label = force_unicode(option_label)
btn = ButtonWidget(attrs=dict(btn_attrs, text=option_label, value=option_value))
rendered_btn = btn.render(attrs=btn_attrs)
btn_container.append(rendered_btn)
cb = CheckboxInput(data_attrs, check_test=lambda x: x in value)
rendered_cb = cb.render(name, option_value)
data_container.append(rendered_cb)
btn = '<div%s>%s</div>' % (flatatt(btn_container_attrs), join(btn_container))
data = '<div%s>%s</div>' % (flatatt(data_container_attrs), join(data_container))
output.append(btn)
output.append(data)
return mark_safe(u'\n'.join(output))
def render(self, name, value, attrs=None):
if value is None:
value = ''
final_attrs = self.build_attrs(attrs, name=name, readonly="readonly", type="text")
if value != '':
# Only add the 'value' attribute if a value is non-empty.
final_attrs['value'] = force_text(self._format_value(value))
return format_html("""
<div class="input-group">
<input class="form-control" {0}>
<span class="input-group-btn">
<button class="btn btn-primary" data-toggle="modal" href="#phonenumber-search" type="button">Search for Available Numbers</button>
</span>
</div><!-- /input-group -->
""", flatatt(final_attrs))
def render(self, name, selected=None, attrs=None, choices=()):
attrs['id'] = 'TagSelectorWidget-' + ''.join(
random.choice(string.ascii_uppercase + string.digits)
for x in range(10))
if selected is None: selected = []
final_attrs = self.build_attrs(attrs, name=name)
output = [
u'<select multiple="multiple" class="chosen" %s>' %
flatatt(final_attrs)
]
options = self.render_options(choices, selected)
if options:
output.append(options)
output.append('</select>')
return mark_safe(u'\n'.join(output))
def render(self, name, value, attrs=None):
attrs['id'] = 'NumberSliderWidget-' + ''.join(
random.choice(string.ascii_uppercase + string.digits)
for x in range(10))
final_attrs = self.build_attrs(attrs, name=name)
output = [u'<input type="number" class="number-slider-widget" value="%s" data-slider-min="1" data-slider-max="63" data-slider-step="1" id="%s" %s>' \
% (value, attrs['id'], flatatt(final_attrs))]
output.append('''<script type="text/javascript">$('#%s').slider({
selection: 'before',
value: %s,
formater: function(value) {
return 'days to discuss before voting: '+value+ ' days';
}
});</script>''' % (attrs['id'], value))
return mark_safe(u'\n'.join(output))
def render(self, name, value, attrs={}):
if value is None: value = ''
final_attrs = self.build_attrs(attrs, name=name)
# self.config['filebrowserUploadUrl'] = reverse('ckeditor_upload')
# self.config['filebrowserBrowseUrl'] = reverse('ckeditor_browse')
return mark_safe(u'''<textarea{flat_attrs}>{value}</textarea>
<script type="text/javascript">
django.jQuery(function() {{
django.jQuery("#{id}").cleditor();
}})
</script>'''.format(
flat_attrs=flatatt(final_attrs),
value=value,
id=final_attrs.get('id'),
))
def render(self, name, value, attrs=None):
if value is None: value = ''
final_attrs = self.build_attrs(attrs, name=name)
textarea_widget = u'<textarea%s>%s</textarea>' % (
flatatt(final_attrs), conditional_escape(force_text(value)))
wid = final_attrs.get('id', 'unknown')
toolbar_widget = self.render_toolbar_widget(wid)
pos = wid.find('__prefix__')
if pos != -1:
js_widget = self.render_js_delay_widget(wid, pos)
else:
js_widget = self.render_js_init_widget(wid)
return mark_safe(u'<div style="display:inline-block">' +
toolbar_widget + textarea_widget + u'</div>' +
js_widget)
def render(self, name, value, attrs=None):
if value is None: value = ''
final_attrs = self.build_attrs(attrs, name=name)
output = []
output.append(
u'<a href="javascript: toggle(\'notes_%s\',\'img_%s\'); "><img id=\'img_%s\' src=\'/static/img/admin/icon_changelink.gif\' /></a>'
% (final_attrs["id"], final_attrs["id"], final_attrs["id"]))
output.append(
u'<div style=\'z-index: 10000; display: none;\' id=\'notes_%s\'>' %
final_attrs["id"])
output.append(
u'<textarea%s>%s</textarea>' %
(flatatt(final_attrs), conditional_escape(force_unicode(value))))
output.append("</div>")
return mark_safe(u' '.join(output))
def label_tag(self, contents=None, attrs=None):
"""
Wraps the given contents in a <label>, if the field has an ID attribute.
Does not HTML-escape the contents. If contents aren't given, uses the
field's HTML-escaped label.
If attrs are given, they're used as HTML attributes on the <label> tag.
"""
contents = contents or conditional_escape(self.label)
widget = self.field.widget
id_ = widget.attrs.get('id') or self.auto_id
if id_:
attrs = attrs and flatatt(attrs) or ''
contents = '<label for="%s"%s>%s</label>' % (widget.id_for_label(id_), attrs, unicode(contents))
return mark_safe(contents)
def render(self, name, value, attrs=None):
final_attrs = self.build_attrs(attrs, type='checkbox', name=name)
try:
result = self.check_test(value)
except: # Silently catch exceptions
result = False
if result:
final_attrs['checked'] = 'checked'
if value not in ('', True, False, 'True', 'False', None):
# Only add the 'value' attribute if a value is non-empty.
final_attrs['value'] = force_unicode(value)
return mark_safe(u'<input%s />' % flatatt(final_attrs))
def render(self, name, value, attrs=None):
if value is None:
value = ''
final_attrs = self.build_attrs(attrs, type=self.input_type, name=name)
if value != '':
# Only add the 'value' attribute if a value is non-empty.
if str(value).find('.') == -1:
value = Decimal(str(value) + '.00')
elif str(value).split('.'):
if len(str(value).split('.')[1]) < 2:
value = Decimal(str(value) + '0')
final_attrs['value'] = force_unicode(self._format_value(value))
return mark_safe(u'<input%s alt="area" /> m²' % flatatt(final_attrs))
def render(self, name, value, attrs=None):
taxo_attrs = self.build_attrs(None,
name=name,
id="id_" + name,
type='hidden')
# Only add the 'value' attribute if a value is non-empty.
taxo_attrs['value'] = force_text(self._format_value(value))
view_attrs = self.build_attrs(attrs, name=name + "_view", type='text')
view_attrs['id'] = "id_" + name + "_view"
# import pdb ; pdb.set_trace()
# /* */
return format_html(
r'''
<input {0}/>
<input {1} value=""><br>
<label>Visualization:</label>
<select id="OutTypeCB" onChange="
taxonomy_update();
">
<option value="0">Full</option>
<option value="1">Omit Unknown</option>
<option value="2" selected>Short</option>
</select>
''', flatatt(taxo_attrs), flatatt(view_attrs))
def render(self, name, value, attrs=None, choices=()):
if value is None: value = ''
final_attrs = self.build_attrs(attrs, name=name)
final_attrs['data-type'] = name
output = [format_html(u'<div{0}>Валюта:', flatatt(final_attrs))]
for option_value, option_label in chain(self.choices, choices):
_active_str = ''
if value == option_value:
_active_str = ' active '
output.append(
format_html(u'<span class="{0}" data-value="{1}">{2}</span>',
_active_str, option_value, option_label))
output.append(u'</div>')
return mark_safe('\n'.join(output))
def render(self, name, value, attrs={}):
if value is None:
value = ''
final_attrs = self.build_attrs(attrs, name=name)
self.config.setdefault('filebrowserUploadUrl',
reverse('ckeditor_upload'))
self.config.setdefault('filebrowserBrowseUrl',
reverse('ckeditor_browse'))
return mark_safe(
render_to_string(
'ckeditor/widget.html', {
'final_attrs': flatatt(final_attrs),
'value': conditional_escape(force_text(value)),
'id': final_attrs['id'],
'config': json_encode(self.config)
}))
def label_tag(self, contents=None, attrs=None):
"""
Wraps the given contents in a <label>, if the field has an ID attribute.
contents should be 'mark_safe'd to avoid HTML escaping. If contents
aren't given, uses the field's HTML-escaped label.
If attrs are given, they're used as HTML attributes on the <label> tag.
"""
contents = contents or conditional_escape(self.label)
widget = self.field.widget
id_ = widget.attrs.get('id') or self.auto_id
if id_:
attrs = attrs and flatatt(attrs) or ''
contents = format_html('<label for="{0}"{1}>{2}</label>',
widget.id_for_label(id_), attrs, contents)
return mark_safe(contents)
def render(self, name, value, attrs=None):
code = get_current_code()
empty_current_code()
input_attrs = self.build_attrs(attrs, type='text', name=name)
src = reverse(draw, kwargs={'code': code})
return mark_safe(
self.template % {
'src': src,
'input_attrs': flatatt(input_attrs),
'alt': settings.ALT,
'width': WIDTH,
'length': LENGTH,
'height': HEIGHT,
'rnd': random(),
'refresh_text': REFRESH_LINK_TEXT
})
def render(self, name, value, attrs={}):
if value is None:
value = ''
final_attrs = self.build_attrs(attrs, name=name)
self.options['filebrowserBrowseUrl'] = reverse('cked_elfinder')
return mark_safe(
render_to_string(
'cked/ckeditor.html', {
'final_attrs': flatatt(final_attrs),
'value': conditional_escape(force_unicode(value)),
'id': final_attrs['id'],
'options': json_encode(self.options)
}))
def render(self, name, value, attrs=None):
attrs = attrs or {}
ace_attrs = {
"class": "django-ace-widget loading",
}
if self.mode:
ace_attrs["data-mode"] = self.mode
if self.theme:
ace_attrs["data-theme"] = self.theme
if self.wordwrap:
ace_attrs["data-wordwrap"] = "true"
textarea = super(AceWidget, self).render(name, value, attrs)
return mark_safe('<div%s><div></div></div>%s' %
(flatatt(ace_attrs), textarea))
