return [
block.name,
block.field.widget,
meta,
]
@cached_property
def media(self):
return forms.Media(
js=[
versioned_static("wagtailadmin/js/telepath/blocks.js"),
]
)
register(FieldBlockAdapter(), FieldBlock)
class CharBlock(FieldBlock):
def __init__(
self,
required=True,
help_text=None,
max_length=None,
min_length=None,
validators=(),
**kwargs,
):
# CharField's 'label' and 'initial' parameters are not exposed, as Block handles that functionality natively
# (via 'label' and 'default')
self.field = forms.CharField(
def render_js_init(self, id_, name, value_data):
return "new SnippetChooser({id});".format(id=json.dumps(id_))
@cached_property
def media(self):
return forms.Media(
js=[
versioned_static("wagtailadmin/js/chooser-modal.js"),
versioned_static("wagtailsnippets/js/snippet-chooser.js"),
]
)
class SnippetChooserAdapter(BaseChooserAdapter):
js_constructor = "wagtail.snippets.widgets.SnippetChooser"
@cached_property
def media(self):
return forms.Media(
js=[
versioned_static("wagtailsnippets/js/snippet-chooser-telepath.js"),
]
)
register(SnippetChooserAdapter(), AdminSnippetChooser)
class SnippetListingButton(ListingButton):
pass
)
def render_js_init(self, id_, name, value_data):
return "createDocumentChooser({0});".format(json.dumps(id_))
@property
def media(self):
return forms.Media(js=[
versioned_static("wagtaildocs/js/document-chooser-modal.js"),
versioned_static("wagtaildocs/js/document-chooser.js"),
])
class DocumentChooserAdapter(WidgetAdapter):
js_constructor = "wagtail.documents.widgets.DocumentChooser"
def js_args(self, widget):
return [
widget.render_html("__NAME__", None, attrs={"id": "__ID__"}),
widget.id_for_label("__ID__"),
]
@cached_property
def media(self):
return forms.Media(js=[
versioned_static("wagtaildocs/js/document-chooser-telepath.js"),
])
register(DocumentChooserAdapter(), AdminDocumentChooser)
)
def render_js_init(self, id_, name, value_data):
return "createImageChooser({0});".format(json.dumps(id_))
@property
def media(self):
return forms.Media(js=[
versioned_static("wagtailimages/js/image-chooser-modal.js"),
versioned_static("wagtailimages/js/image-chooser.js"),
])
class ImageChooserAdapter(WidgetAdapter):
js_constructor = "wagtail.images.widgets.ImageChooser"
def js_args(self, widget):
return [
widget.render_html("__NAME__", None, attrs={"id": "__ID__"}),
widget.id_for_label("__ID__"),
]
@cached_property
def media(self):
return forms.Media(js=[
versioned_static("wagtailimages/js/image-chooser-telepath.js"),
])
register(ImageChooserAdapter(), AdminImageChooser)
return [
error.non_block_errors.as_data(),
{
block_id: child_errors.as_data()
for block_id, child_errors in error.block_errors.items()
},
]
@cached_property
def media(self):
return forms.Media(js=[
versioned_static("wagtailadmin/js/telepath/blocks.js"),
])
register(StreamBlockValidationErrorAdapter(), StreamBlockValidationError)
class BaseStreamBlock(Block):
def __init__(self, local_blocks=None, **kwargs):
self._constructor_kwargs = kwargs
super().__init__(**kwargs)
# create a local (shallow) copy of base_blocks so that it can be supplemented by local_blocks
self.child_blocks = self.base_blocks.copy()
if local_blocks:
for name, block in local_blocks:
block.set_name(name)
self.child_blocks[name] = block
class Album:
def __init__(self, title, artists):
self.title = title
self.artists = artists
class ArtistAdapter(Adapter):
js_constructor = "music.Artist"
def js_args(self, obj):
return [obj.name]
register(ArtistAdapter(), Artist)
class AlbumAdapter(Adapter):
js_constructor = "music.Album"
def js_args(self, obj):
return [obj.title, obj.artists]
class Media:
js = ["music_player.js"]
register(AlbumAdapter(), Album)
return self.converter.to_database_format(original_value)
@cached_property
def media(self):
media = Media(
js=[
versioned_static("wagtailadmin/js/draftail.js"),
],
css={
"all":
[versioned_static("wagtailadmin/css/panels/draftail.css")]
},
)
for plugin in self.plugins:
media += plugin.media
return media
class DraftailRichTextAreaAdapter(WidgetAdapter):
js_constructor = "wagtail.widgets.DraftailRichTextArea"
def js_args(self, widget):
return [
widget.options,
]
register(DraftailRichTextAreaAdapter(), DraftailRichTextArea)
widget.client_options,
]
class AdminPageMoveChooser(AdminPageChooser):
def __init__(self,
target_models=None,
can_choose_root=False,
user_perms=None,
**kwargs):
self.pages_to_move = kwargs.pop("pages_to_move", [])
super().__init__(
target_models=target_models,
can_choose_root=can_choose_root,
user_perms=user_perms,
**kwargs,
)
@property
def client_options(self):
return {
"model_names": self.model_names,
"can_choose_root": self.can_choose_root,
"user_perms": self.user_perms,
"target_pages": self.pages_to_move,
"match_subclass": False,
}
register(PageChooserAdapter(), AdminPageChooser)
]
def get_media(self, widget):
media = super().get_media(widget)
return media + widget.media
@cached_property
def media(self):
return forms.Media(
js=[
versioned_static("wagtailadmin/js/telepath/widgets.js"),
]
)
register(WidgetAdapter(), forms.widgets.Input)
register(WidgetAdapter(), forms.Textarea)
register(WidgetAdapter(), forms.CheckboxSelectMultiple)
class CheckboxInputAdapter(WidgetAdapter):
js_constructor = "wagtail.widgets.CheckboxInput"
register(CheckboxInputAdapter(), forms.CheckboxInput)
class RadioSelectAdapter(WidgetAdapter):
js_constructor = "wagtail.widgets.RadioSelect"
{
"addressField": widget.address_field,
"zoomField": widget.zoom_field,
"defaultLocation": GEO_WIDGET_DEFAULT_LOCATION,
"srid": widget.srid,
"zoom": widget.zoom,
"showEmptyLocation": GEO_WIDGET_EMPTY_LOCATION,
"translations": translations,
},
]
class Media:
js = ["wagtailgeowidget/js/google-maps-field-telepath.js"]
register(GoogleMapsFieldAdapter(), GoogleMapsField)
class GeoField(GoogleMapsField):
def __init__(self, *args, **kwargs):
import warnings
warnings.warn(
"GeoField will be deprecated in version 7, use GoogleMapsField instead",
PendingDeprecationWarning,
)
super().__init__(*args, **kwargs)
# class GeocoderField(forms.HiddenInput):
return [
[
elist.as_data() if elist is not None else elist
for elist in error.block_errors
],
error.non_block_errors.as_data(),
]
@cached_property
def media(self):
return forms.Media(js=[
versioned_static("wagtailadmin/js/telepath/blocks.js"),
])
register(ListBlockValidationErrorAdapter(), ListBlockValidationError)
class ListValue(MutableSequence):
"""
The native data type used by ListBlock. Behaves as a list of values, but also provides
a bound_blocks property giving access to block IDs
"""
class ListChild(BoundBlock):
# a wrapper for list values that keeps track of the associated block type and ID
def __init__(self, *args, **kwargs):
self.id = kwargs.pop("id", None) or str(uuid.uuid4())
super().__init__(*args, **kwargs)
def get_prep_value(self):
return {
class StaticBlockAdapter(Adapter):
js_constructor = "wagtail.blocks.StaticBlock"
def js_args(self, block):
admin_text = block.get_admin_text()
if isinstance(admin_text, SafeString):
text_or_html = "html"
else:
text_or_html = "text"
return [
block.name,
{
text_or_html: admin_text,
"icon": block.meta.icon,
"label": block.label,
},
]
@cached_property
def media(self):
return forms.Media(
js=[
versioned_static("wagtailadmin/js/telepath/blocks.js"),
]
)
register(StaticBlockAdapter(), StaticBlock)
"Table caption":
_("Table caption"),
"A heading that identifies the overall topic of the table, and is useful for screen reader users":
_("A heading that identifies the overall topic of the table, and is useful for screen reader users"
),
"Table":
_("Table"),
}
return [
widget.table_options,
strings,
]
register(TableInputAdapter(), TableInput)
class TableBlock(FieldBlock):
def __init__(self,
required=True,
help_text=None,
table_options=None,
**kwargs):
"""
CharField's 'label' and 'initial' parameters are not exposed, as Block
handles that functionality natively (via 'label' and 'default')
CharField's 'max_length' and 'min_length' parameters are not exposed as table
data needs to have arbitrary length
"""
def media(self):
return forms.Media(js=[
versioned_static("wagtailadmin/js/date-time-chooser.js"),
])
class AdminDateInputAdapter(WidgetAdapter):
js_constructor = "wagtail.widgets.AdminDateInput"
def js_args(self, widget):
return [
widget.get_config(),
]
register(AdminDateInputAdapter(), AdminDateInput)
class AdminTimeInput(widgets.TimeInput):
template_name = "wagtailadmin/widgets/time_input.html"
def __init__(self, attrs=None, format=None):
default_attrs = {"autocomplete": "off"}
if attrs:
default_attrs.update(attrs)
fmt = format
if fmt is None:
fmt = getattr(settings, "WAGTAIL_TIME_FORMAT", DEFAULT_TIME_FORMAT)
self.js_format = to_datetimepicker_format(fmt)
super().__init__(attrs=default_attrs, format=fmt)
from django.forms import widgets
from wagtail.telepath import register
from wagtail.widget_adapters import WidgetAdapter
class AdminAutoHeightTextInput(widgets.Textarea):
template_name = "wagtailadmin/widgets/auto_height_text_input.html"
def __init__(self, attrs=None):
# Use more appropriate rows default, given autoheight will alter this anyway
default_attrs = {"rows": "1"}
if attrs:
default_attrs.update(attrs)
super().__init__(default_attrs)
class AdminAutoHeightTextInputAdapter(WidgetAdapter):
js_constructor = "wagtail.widgets.AdminAutoHeightTextInput"
register(AdminAutoHeightTextInputAdapter(), AdminAutoHeightTextInput)
return [{
row_index: {
col_index: cell_error
for col_index, cell_error in row_errors.items()
}
for row_index, row_errors in error.cell_errors.items()
}]
@cached_property
def media(self):
return forms.Media(js=[
versioned_static("typed_table_block/js/typed_table_block.js"),
])
register(TypedTableBlockValidationErrorAdapter(),
TypedTableBlockValidationError)
class TypedTable:
template = "typed_table_block/typed_table_block.html"
def __init__(self, columns, row_data):
# a list of dicts, each with items 'block' (the block instance) and 'heading'
self.columns = columns
# a list of dicts, each with an item 'values' (the list of block values)
self.row_data = row_data
@property
def rows(self):
"""
