def create_entry_link(self, item):
link = Element("a")
link.add_class("entry_link")
link["href"] = self.get_entry_url(item)
link.append(self.get_item_label(item))
return link
def create_group_row(self, group):
row = Element("tr")
row.add_class("group")
cell = Element(
"td",
colspan=len(self.head_row.children),
children=[
Element("span",
class_name="grouping_value",
children=[
self.grouping.translate_grouping_value(group)
or self.translate_value(
self.data, self.grouping.member, group)
]),
Element("span",
class_name="grouping_member",
children=[self._grouping_member_translation]),
Element("a",
href="?" +
get_request_query(grouping="", page=0).escape(),
class_name="remove_grouping",
children=[self._remove_grouping_translation])
])
row.append(cell)
return row
def create_entry(self, item):
entry = Element()
entry.add_class("entry")
entry.control = self.create_control(item)
entry.append(entry.control)
entry.remove_button = self.create_remove_button(item)
entry.append(entry.remove_button)
return entry
def create_group(self, group, members):
tbody = Element("tbody")
if group:
tbody.add_class(group.replace(".", "_") + "_group")
tbody.header_row = self.create_group_header(group)
if tbody.header_row:
tbody.append(tbody.header_row)
self._create_rows(members, tbody)
return tbody
def create_entry(self, item):
entry = Element()
entry.add_class("entry")
if self.is_selected(item):
entry.add_class("selected")
link = self.create_entry_link(item)
entry.append(link)
return entry
def create_group_header(self, group):
label = self.get_group_label(group)
if label:
row = Element("tr")
row.add_class("group_header")
th = Element("th")
th["colspan"] = 2
th.append(label)
row.header = th
row.append(th)
return row
def _fill_head(self):
# Cache sorted columns
if self.order:
self._sorted_columns = sorted_columns = {}
for criteria in self.order:
sign = criteria.__class__
expr = criteria.operands[0]
if isinstance(expr, TranslationExpression):
member = expr.operands[0].name
language = expr.operands[1].value
else:
member = expr.name
language = None
sorted_columns[(member, language)] = sign
# Selection column
if (self.selection_mode != NO_SELECTION
and self.use_separate_selection_column):
selection_header = Element("th")
selection_header.add_class("selection")
self.head_row.append(selection_header)
# Column groups
if not self.grouped or not self.column_groups_displayed:
self.column_groups_row.visible = False
# Regular columns
if self.grouped:
self.columns_by_group = list(self.displayed_members_by_group)
else:
self.columns_by_group = [(None, list(self.displayed_members))]
for group, columns in self.columns_by_group:
if self.grouped and self.column_groups_displayed:
self.column_groups_row.append(
self.create_column_group_header(group, columns))
for column in columns:
if column.translated:
for language in self.translations or (get_language(), ):
header = self.create_header(column, language)
self.head_row.append(header)
else:
header = self.create_header(column)
self.head_row.append(header)
def create_cell(self, item, column, language=None):
cell = Element("td")
if language:
cell["dir"] = directionality.get(language)
if (self.order and (column.name, language) in self._sorted_columns
and not (self.user_collection
and not self.user_collection.allow_sorting)):
cell.add_class("sorted")
self._init_cell(cell, column, language)
display = self.create_member_display(
item, column, self.get_member_value(item, column))
cell.append(display)
return cell
def read_only_display(ui_generator, obj, member, value, **context):
read_only_ui_generator = (ui_generator.read_only_ui_generator
or default_display)
element = Element()
element.add_class("read_only_display")
element.display = read_only_ui_generator.create_member_display(
obj, member, value, **context)
element.append(element.display)
element.hidden_input = HiddenInput()
element.append(element.hidden_input)
element.data_binding_delegate = element.hidden_input
return element
def create_entry(self, key, value):
entry = Element()
entry.add_class("entry")
entry.key_control = self.create_key_control(key, value)
entry.append(entry.key_control)
entry.value_control = self.create_value_control(key, value)
entry.append(entry.value_control)
if not self.fixed_entries:
entry.remove_button = self.create_remove_button(key, value)
entry.append(entry.remove_button)
return entry
def create_row(self, index, item):
self.__split_row_iterators.clear()
self.__split_row_values.clear()
row = Element("tr")
row.add_class(index % 2 == 0 and "odd" or "even")
if (self.selection_mode != NO_SELECTION
and self.use_separate_selection_column):
row.append(self.create_selection_cell(item))
if self.schema.primary_member:
row["id"] = item.id
for group, columns in self.columns_by_group:
for column in columns:
if self.translations and column.translated:
for language in self.translations:
with language_context(language):
cell = self.create_cell(item, column, language)
row.append(cell)
else:
key = column.name
sequence_factory = self.__split_rows.get(key)
if sequence_factory is not None:
iterator = iter(sequence_factory(item))
self.__split_row_iterators[key] = iterator
try:
value = next(iterator)
except StopIteration:
value = None
self.__split_row_values[key] = value
cell = self.create_cell(item, column)
row.append(cell)
if (self.selection_mode != NO_SELECTION
and not self.use_separate_selection_column):
row.children[0].insert(0, self.create_selection_control(item))
return row
def create_entry(self, item):
entry = Element()
entry.add_class("radio_entry")
entry.input = Element("input")
entry.input["type"] = "radio"
entry.input["value"] = self.get_item_value(item)
entry.input["checked"] = self.is_selected(item)
entry.input["name"] = self.name
entry.append(entry.input)
entry.label = self.create_label(item)
if entry.label.tag == "label":
entry.label["for"] = entry.input.require_id()
entry.append(entry.label)
return entry
def create_selection_control(self, item):
id = self.get_item_id(item)
selection_control = Element("input")
selection_control["name"] = self.selection_parameter
selection_control["id"] = "selection_" + str(id)
selection_control["value"] = id
selection_control["autocomplete"] = "off"
selection_control.add_class("row_selection_control")
if self.selection_mode == SINGLE_SELECTION:
selection_control["type"] = "radio"
else:
selection_control["type"] = "checkbox"
selection_control["checked"] = self.is_selected(item)
return selection_control
def create_translated_values(self, member):
cell = Element("td")
table = Element("table")
table.add_class("translated_values")
cell.append(table)
for language in (self.translations or (get_language(), )):
language_row = Element("tr")
language_row.add_class(language)
table.append(language_row)
language_label = Element("th")
language_label.append(translations(language))
language_row.append(language_label)
with language_context(language):
language_value_cell = self.create_value(member)
language_row.append(language_value_cell)
return cell
def create_member_row(self, member):
row = Element("tr")
row.add_class("member_row")
row.add_class(member.name + "_member")
label = self.create_label(member)
row.append(label)
if member.translated:
row.add_class("translated")
row.append(self.create_translated_values(member))
else:
row.append(self.create_value(member))
return row
def test_add_class(self):
from cocktail.html.element import Element
e = Element()
# Adding a class works as expected
e.add_class("craptastic")
self.assertEqual(e["class"], "craptastic")
self.assertEqual(e.classes, ["craptastic"])
# Adding a second class works ok
e.add_class("shiny")
self.assertEqual(e["class"], "craptastic shiny")
self.assertEqual(e.classes, ["craptastic", "shiny"])
# Adding an existing class is a no-op
e.add_class("shiny")
self.assertEqual(e["class"], "craptastic shiny")
self.assertEqual(e.classes, ["craptastic", "shiny"])
def test_remove_class(self):
from cocktail.html.element import Element
e = Element()
# Removing an undefined class is a no-op
e.remove_class("big")
e.add_class("craptastic")
e.add_class("shiny")
e.add_class("important")
e.remove_class("shiny")
self.assertEqual(e["class"], "craptastic important")
self.assertEqual(e.classes, ["craptastic", "important"])
e.remove_class("important")
self.assertEqual(e["class"], "craptastic")
self.assertEqual(e.classes, ["craptastic"])
e.remove_class("craptastic")
self.assertEqual(e["class"], None)
self.assertEqual(e.classes, [])
def create_translation_label(self, language):
label = Element("span")
label.add_class("translation")
label.append("(" + translate_locale(language) + ")")
return label
def create_add_button(self):
button = Element("button")
button.add_class("add_button")
button["type"] = "button"
button.append("✚")
return button
def create_remove_button(self, key, value):
button = Element("button")
button.add_class("remove_button")
button["type"] = "button"
button.append("✖")
return button
def create_entries(self):
entries = Element()
entries.add_class("entries")
return entries
def create_selection_cell(self, item):
selection_cell = Element("td")
selection_cell.add_class("selection")
selection_cell.append(self.create_selection_control(item))
return selection_cell
def create_column_group_header(self, group, columns):
header = Element("th")
header.add_class("column_group")
header["colspan"] = len(columns)
header.append(self.get_column_group_header_label(group, columns))
return header
