def _ready(self):
value = self.value
spellcheck = self.spellcheck
if self.member:
try:
value = serialize_parameter(self.member, value)
except:
pass
if self.member.required == True:
self["required"] = True
format = getattr(self.member, "format", None)
if format:
self["pattern"] = format.pattern
# Limit the length of the control
if isinstance(self.member, String) \
and self.member.max is not None:
self["maxlength"] = str(self.member.max)
if spellcheck is None:
spellcheck = self.member.spellcheck
if spellcheck:
self["spellcheck"] = True
self["value"] = value
Element._ready(self)
def _ready(self):
if self.width:
self["width"] = self.width
if self.height:
self["height"] = self.height
if self.autoplay:
self["autoplay"] = "autoplay"
if self.show_player_controls:
self["controls"] = "controls"
self.set_client_param(
"mediaElementOptions",
self.media_element_options
)
for url, mime_type in self.sources:
source = Element("source")
source["src"] = url
source["type"] = mime_type
self.append(source)
Element._ready(self)
def _ready(self):
value = self.value
spellcheck = self.spellcheck
if self.member:
try:
value = serialize_parameter(self.member, value)
except:
pass
if self.member.required == True:
self["required"] = True
format = getattr(self.member, "format", None)
if format:
self["pattern"] = format.pattern
if spellcheck is None:
spellcheck = self.member.spellcheck
if spellcheck == False:
self["spellcheck"] = False
if value:
self.append(value)
Element._ready(self)
def _render(self, rendering):
if self.rendered:
if not self.ie_versions:
Element._render(self, rendering)
return
css_class = self["class"] or ""
for version in self.ie_versions:
rendering.write("<!--[if IE %d]>" % version)
self["class"] = (css_class + " IE IE%d" % version).lstrip()
rendering.renderer.write_element_opening(self, rendering)
rendering.write("<![endif]-->")
rendering.write("<!--[if !IE]> -->")
self["class"] = (css_class + " not_IE").lstrip()
should_write_content = \
rendering.renderer.write_element_opening(self, rendering)
rendering.write("<!-- <![endif]-->")
self["class"] = css_class
if should_write_content:
rendering.renderer.write_element_content(self, rendering)
rendering.renderer.write_element_closure(self, rendering)
def _ready(self):
Element._ready(self)
# Find the selected path
if not (self.expanded and not self.highlighted_selection):
self._expanded = set()
item = self.selection
while item is not None:
self._expanded.add(item)
item = self.get_parent_item(item)
if self.root is not None:
if self.root_visibility == self.SINGLE_ROOT:
self._depth = 2
if not self.filter_item or self._is_accessible(self.root):
self.root_entry = self.create_entry(self.root)
self.append(self.root_entry)
else:
self._depth = 1
if self.root_visibility == self.ITERABLE_ROOT:
children = self.root
else:
children = self.get_expanded_children(self.root)
if self.root_visibility == self.MERGED_ROOT:
children = [self.root] + list(children)
self._fill_children_container(self, self.root, children)
self.__item_access = None
def _ready(self):
Element._ready(self)
item_translator = None
if self.member:
if self.items is None and self.groups is None:
self.items = self._get_items_from_member(self.member)
if isinstance(self.member, schema.Collection):
if self.member.items:
item_translator = self.member.items.translate_value
else:
item_translator = self.member.translate_value
self._item_translator = (item_translator or
(lambda item, **kw: translations(item, **kw)))
Grouping.init_element(self)
if self.value is None:
self._is_selected = lambda item: item is None
elif (isinstance(self.value,
(list, tuple, set, ListWrapper, SetWrapper))
and not isinstance(self.member, schema.Tuple)):
self._is_selected = lambda item: item in self.value
else:
self._is_selected = lambda item: item == self.value
self._fill_entries()
def __init__(self, *args, **kwargs):
DataDisplay.__init__(self)
self.__groups = []
self.groups = ListWrapper(self.__groups)
self.__hidden_members = {}
kwargs.setdefault("action", "")
Element.__init__(self, *args, **kwargs)
def _ready(self):
Element._ready(self)
options = self.recaptcha_options.copy()
language = get_language()
options["lang"] = language
if language == "ca":
options["lang"] = "es"
options["custom_translations"] = {
"instructions_visual": "Escriu les 2 paraules:",
"instructions_audio": "Escriu el que sentis:",
"play_again": "Tornar a escoltar",
"cant_hear_this": "Descarregar so en MP3",
"visual_challenge": "Obtindre un repte visual",
"audio_challenge": "Obtindre un repte audible",
"refresh_btn": "Obtindre un nou repte",
"help_btn": "Ajuda",
"incorrect_try_again": "Incorrecte. Torna a provar-ho."
}
elif language not in ("en", "nl", "fr", "de", "pt", "ru", "es", "tr"):
options["lang"] = "en"
if ReCaptchaExtension.instance.theme == "custom":
options.setdefault(
"custom_theme_widget",
ReCaptchaExtension.instance.custom_theme_widget
)
options.setdefault("theme", ReCaptchaExtension.instance.theme)
init_options = Element("script")
init_options["type"] = "text/javascript"
init_options.append("var RecaptchaOptions = %s;" % dumps(options))
init_script = Element()
init_script.append("""<script type="text/javascript" src="%(api_server)s/challenge?k=%(public_key)s%(error_param)s"></script>
<noscript>
<iframe src="%(api_server)s/noscript?k=%(public_key)s%(error_param)s" style="height: 300px; width: 500px; border: 0;" ></iframe><br />
<textarea name="recaptcha_challenge_field" rows="3" cols="40"></textarea>
<input type='hidden' name='recaptcha_response_field' value='manual_challenge' />
</noscript>
""" % self.recaptcha_params)
self.append(init_options)
if ReCaptchaExtension.instance.theme == "custom":
custom_container = templates.new(
ReCaptchaExtension.instance.custom_template
)
custom_container.widgetid = ReCaptchaExtension.instance.custom_theme_widget
self.append(custom_container.render())
self.append(init_script)
def create_delete_button(self):
delete_button = Element("button",
name="relation-unlink",
type="submit",
class_name="ItemSelector-button delete",
value=self.member.name)
delete_button.append(translations("woost.views.ItemSelector delete"))
return delete_button
def create_edit_button(self):
edit_button = Element("button",
name="relation-edit",
type="submit",
class_name="ItemSelector-button edit",
value=self.member.name)
edit_button.append(translations("woost.views.ItemSelector edit"))
return edit_button
def _content_ready(self):
Element._content_ready(self)
for derived_content_type in self.value.derived_schemas():
break
else:
self._last_entry.selector.tree.visible = False
self._last_entry.add_class("leaf")
def __init__(self, *args, **kwargs):
Element.__init__(self, *args, **kwargs)
self.recaptcha_params = {
"public_key": ReCaptchaExtension.instance.public_key,
"api_server": self.API_SSL_SERVER if ReCaptchaExtension.instance.ssl
else self.API_SERVER,
"error_param": "&error=%s" % ("",)
}
self.recaptcha_options = {}
def _ready(self):
if self.member:
# Limit accepted mime types
if self.member["mime_type"].enumeration:
self["accept"] = \
",".join(ct for ct in self.member["mime_type"].enumeration)
Element._ready(self)
def create_select_button(self):
select_button = Element("button",
name="relation-select",
type="submit",
class_name="ItemSelector-button select",
value=self.member.type.full_name + "-" +
self._param_name)
select_button.append(translations("woost.views.ItemSelector select"))
return select_button
def _ready(self):
if not self.name and self.data_display:
self.name = self.data_display.get_member_name(
self.member, self.language)
if self.root_type:
self.append(self.create_class_entry(self.root_type))
Element._ready(self)
def _ready(self):
value = self.value
if self.member:
try:
value = serialize_parameter(self.member, value)
except:
pass
self["value"] = value
Element._ready(self)
def __call__(self, *args, **kwargs):
node = self.stack_node
previewed_item = self.previewed_item
publishable = self.preview_publishable
preview_language = self.preview_language
user = get_current_user()
# Set the language for the preview
if preview_language:
set_language(preview_language)
# Enforce permissions
user.require_permission(ReadPermission, target=previewed_item)
if publishable is not previewed_item:
user.require_permission(ReadPermission, target=publishable)
# Disable the preview if the item's unsaved state produces validation
# errors; these would usually lead to unhandled server errors during
# rendering.
errors = schema.ErrorList(node.iter_errors())
if errors:
error_box = templates.new("cocktail.html.ErrorBox")
error_box.errors = errors
message = Element("div",
class_name="preview-error-box",
children=[
translations(
"woost.backoffice invalid item preview",
preview_language), error_box
])
message.add_resource("/resources/styles/backoffice.css")
return message.render_page()
# Update the edited item with the data to preview
node.import_form_data(node.form_data, previewed_item)
self.context.update(original_publishable=self.context["publishable"],
publishable=publishable)
controller = publishable.resolve_controller()
if controller is None:
raise cherrypy.NotFound()
if isinstance(controller, type):
controller = controller()
return controller()
def create_row(self, key, value):
row = Element("tr")
row.key_cell = self.create_key_cell(key)
row.append(row.key_cell)
row.value_cell = self.create_value_cell(value)
row.append(row.value_cell)
return row
def _ready(self):
Element._ready(self)
if self.item:
self["draggable"] = "true"
self["data-woost-item"] = self.item.id
for schema in self.item.__class__.descend_inheritance(True):
self.add_class(schema.name)
if self.icon_visible:
self.append(self.create_icon())
self.append(self.get_label())
def create_button(self, name):
button = Element("a")
button.add_class(name)
if name == "next":
button.append(translations("googlesearch next"))
if name == "previous":
button.append(translations("googlesearch previous"))
return button
def _ready(self):
inheritance_line = []
for content_type in self.value.ascend_inheritance(True):
inheritance_line.insert(0, content_type)
if content_type is self.root:
break
for content_type in inheritance_line:
entry = self.create_entry(content_type)
self.append(entry)
self._last_entry = entry
Element._ready(self)
def _ready(self):
Element._ready(self)
params = self.aggregate_tinymce_params()
if self.language:
params.setdefault(
"directionality",
directionality.get(self.language)
)
# Override essential TinyMCE parameters
params["mode"] = "exact"
params["language"] = get_language()
params["elements"] = self.textarea.require_id()
self.set_client_param("tinymceSettings", params);
def create_label(self, content_type):
label = TreeView.create_label(self, content_type)
for schema in content_type.descend_inheritance(True):
label.add_class(schema.name)
img = Element("img")
img["src"] = app.icon_resolver.find_icon_url(
content_type,
self.icon_size
)
img.add_class("icon")
label.insert(0, img)
return label
def _ready(self):
self.set_client_param("mediaElementOptions",
self.media_element_options)
for encoding in self.encodings:
url = get_audio_uri(self.file, encoding)
if url:
source = Element("source")
source["src"] = url
mime_type = guess_type(url, strict=False)
if mime_type:
source["type"] = mime_type[0]
self.append(source)
Element._ready(self)
def _ready(self):
Element._ready(self)
if self.user_collection:
self.subset = self.user_collection.subset
self.page = self.user_collection.page
self.page_size = self.user_collection.page_size
self.page_param_name = \
self.user_collection.params.get_parameter_name(
self.page_size_param_name
)
elif self.pagination:
self.subset = self.pagination.current_page_items
self.page = self.pagination.current_page
self.page_size = self.pagination.page_size
self.page_size_param_name = \
self.pagination.__class__.page_size.get_parameter_name()
if (not self.user_collection or self.user_collection.allow_paging) \
and self.subset:
subset_count = len(self.subset)
# Pager
self.pager.page = self.page
self.pager.page_size = self.page_size
self.pager.item_count = subset_count
# Page size
if self.page_size_editable:
self.page_size_control = self.create_page_size_control()
self.page_size_control.place_after(self.pager)
self.page_size_control.input["value"] = str(self.page_size)
# Item count
self.item_count.append(
translations("cocktail.html.PagingControls.item_count",
page_range=(1 + self.page * self.page_size,
min(subset_count, (self.page + 1) *
self.page_size)),
total_count=subset_count))
else:
self.visible = False
def create_label(self, item):
label = Element("div")
label.add_class("entry_label")
label.append(self.get_item_label(item))
if self.filter_item \
and self._is_accessible(item) != ACCESSIBLE:
label.add_class("filtered")
else:
url = self.get_item_url(item)
if url is not None:
label.tag = "a"
label["href"] = url
return label
def _build(self):
Element._build(self)
data_bound(self)
self.add_resource("/resources/scripts/ItemSelector.js")
self.set_client_param("emptyLabel", self.empty_label)
self.input = templates.new("cocktail.html.HiddenInput")
self.append(self.input)
self.binding_delegate = self.input
self.selection_label = templates.new("woost.views.ItemLabel")
self.selection_label.tag = "span"
self.selection_label.add_class("selection_label")
self.append(self.selection_label)
self.buttons = self.create_buttons()
self.append(self.buttons)
def _ready(self):
styles = [
"%s=%s" % (translations(style), style.class_name)
for style in Style.select({"applicable_to_text": True})
]
d = self.tinymce_params.setdefault
d("theme_advanced_styles", ";".join(styles))
d("init_instance_callback", "woost.initRichTextEditor")
load_plugin = Element("script")
load_plugin["type"] = "text/javascript"
load_plugin.append(
"tinymce.PluginManager.load('advimagescale', '/resources/scripts/advimagescale/editor_plugin.js');"
)
self.append(load_plugin)
TinyMCE._ready(self)
def _ready(self):
Element._ready(self)
if self.member is not None:
label = self.member.translate_value(self.value, self.language)
if not label:
label = self.get_empty_label()
self.add_class("empty")
self.append(label)
if (self.value is not None and self.language
and self.member.translated
and isinstance(self.data, SchemaObject)
and self.data.__class__.translated):
source_locale = self.data.get_source_locale(self.language)
if source_locale and self.language != source_locale:
self.add_class("inherited_translation")
self["title"] = \
self.get_translation_inheritance_remark(source_locale)
def _fill_container(self, container, items):
for item in items:
entry = self.create_entry(item)
children = self.get_child_items(item)
if children:
children_container = Element("ul")
self._fill_container(children_container, children)
entry.append(children_container)
container.append(entry)
