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)