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 _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):
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 _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):
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 _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 _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 _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)
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 _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 _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 _ready(self):
Element._ready(self)
if self.blocks is None:
if self.container is not None and self.slot is not None:
if isinstance(self.slot, basestring):
slot = self.container.__class__.get_member(self.slot)
else:
slot = self.slot
if slot:
self.depends_on(self.container, slot.cache_part)
self.blocks = getattr(self.container, slot.name, None)
if self.tag in ("ul", "ol"):
self.__wrap = self.wrap_with_list_item
elif self.tag == "table":
self.__wrap = self.wrap_with_table_row
self._fill_blocks()
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 _ready(self):
Element._ready(self)
self._fill_entries()
def _ready(self):
Element._ready(self)
if self.user_collection:
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_param_name
)
if self.user_collection.subset:
self.item_count = len(self.user_collection.subset)
elif self.pagination:
self.page = self.pagination.current_page
self.page_size = self.pagination.page_size
self.page_param_name = \
self.pagination.__class__.page.get_parameter_name(
prefix = self.name_prefix,
suffix = self.name_suffix
)
self.item_count = self.pagination.item_count
page_count = self.page_count
# Hide the pager when only one page is visible
if self.hide_when_empty and page_count < 2:
self.visible = False
return
# First page
if self.page == 0:
self.first_page_button.visible = False
self.previous_page_button.visible = False
else:
self.first_page_button["href"] = self._get_page_link(0)
self.previous_page_button["href"] = self._get_page_link(self.page -
1)
# Last page
if self.page + 1 == page_count:
self.next_page_button.visible = False
self.last_page_button.visible = False
else:
self.next_page_button["href"] = self._get_page_link(self.page + 1)
self.last_page_button["href"] = self._get_page_link(
self.page_count - 1)
# Direct page links
radius = self.visible_pages / 2
start_page = self.page - radius
end_page = self.page + radius
if start_page < 0:
end_page += abs(start_page)
elif end_page >= page_count:
start_page -= (end_page - page_count)
if end_page - start_page >= self.visible_pages:
end_page -= 1
start_page = max(start_page, 0)
end_page = min(end_page, page_count - 1)
for page in range(start_page, end_page + 1):
page_link = self.create_page_link(page)
if page == end_page:
page_link.add_class("last")
self.page_links.append(page_link)
def _ready(self):
Element._ready(self)
if self.member:
if self.data_display:
self._param_name = self.data_display.get_member_name(
self.member, self.language)
else:
self._param_name = self.member.name
if self.existing_items_only or not self.member.integral:
# Select
self.select_button = self.create_select_button()
self.buttons.append(self.select_button)
if not self.existing_items_only:
user = get_current_user()
if self.member.integral:
if self.value is None:
# New
if any(
user.has_permission(CreatePermission,
target=cls)
for cls in self.member.type.schema_tree()):
self.new_button = self.create_new_button()
self.buttons.append(self.new_button)
else:
# Edit
if any(
user.has_permission(ModifyPermission,
target=cls)
for cls in self.member.type.schema_tree()):
self.edit_button = self.create_edit_button()
self.buttons.append(self.edit_button)
# Delete
if any(
user.has_permission(DeletePermission,
target=cls)
for cls in self.member.type.schema_tree()):
self.delete_button = self.create_delete_button()
self.buttons.append(self.delete_button)
elif self.value is not None:
# Edit
if any(
user.has_permission(ModifyPermission, target=cls)
for cls in self.member.type.schema_tree()):
self.edit_button = self.create_edit_button()
self.buttons.append(self.edit_button)
# Unlink
self.unlink_button = self.create_unlink_button()
self.buttons.append(self.unlink_button)
if self.value is None:
self.selection_label.add_class("empty_selection")
self.selection_label.append(self.empty_label)
else:
self.input["value"] = self.value.id
self.selection_label.item = self.value
