lino 24.9.4__py3-none-any.whl → 24.10.0__py3-none-any.whl

lino/__init__.py

@@ -26,11 +26,7 @@ defines no models, some template files, a series of :term:`django-admin commands
 
 """
 
-__version__ = '24.9.4'
-
-# from __future__ import unicode_literals
-# from __future__ import absolute_import
-# from builtins import str
+__version__ = '24.10.0'
 
 # import setuptools  # avoid UserWarning "Distutils was imported before Setuptools"?
 

lino/api/doctest.py

@@ -314,7 +314,7 @@ def get_fields(model, fieldnames=None, columns=None):
             get_field = model.get_data_elem
             if fieldnames is None:
                 fieldnames = model.column_names
-                # get_handle().list_layout.main.columns
+                # get_handle().grid_layout.main.columns
         else:
             get_field = model.parameters.get
             if fieldnames is None:
@@ -773,3 +773,20 @@ def show_change_watchers():
                 [full_model_name(m), ws.master_key, " ".join(sorted(ws.ignored_fields))]
             )
     print(table(headers, rows, max_width=40))
+
+def show_display_modes():
+    """
+    Show the availble display modes per actor.
+    """
+    dml = sorted(constants.DISPLAY_MODES - constants.BASIC_DISPLAY_MODES)
+    headers = ["actor"]
+    headers += dml
+    rows = []
+    for a in sorted(actors.actors_list, key=str):
+        if not a.is_abstract():
+            rows.append(
+                [str(a)] + [
+                    ("x" if dm in a.extra_display_modes else "")
+                        for dm in dml]
+            )
+    print(table(headers, rows))

lino/core/actions.py

@@ -85,7 +85,10 @@ def resolve_layout(cls, k, spec, layout_class, **options):
 def install_layout(cls, k, layout_class, **options):
     """
     - `cls` is the actor (a class object)
-    - `k` is one of 'detail_layout', 'insert_layout', 'params_layout', 'card_layout', 'list_layout'
+
+    - `k` is one of 'grid_layout', 'detail_layout', 'insert_layout',
+      'params_layout', 'card_layout', 'list_layout'
+
     - `layout_class`
 
     """
@@ -437,6 +440,8 @@ class Action(Parametrizable, Permittable):
     On actions that opens_a_window this must be a unique one-letter
     string expressing the window type.
 
+    See `constants.WINDOW_TYPES`.
+
     Allowed values are:
 
     - None : opens_a_window is False
@@ -486,6 +491,12 @@ class Action(Parametrizable, Permittable):
 
         register_params(self)
 
+        if self.callable_from is not None:
+            for c in self.callable_from:
+                if not c in constants.WINDOW_TYPES:
+                    raise Exception(f"Invalid window_type spec {c} in {self}")
+
+
     def __get__(self, instance, owner):
         """
         When a model has an action "foo", then getting an attribute
@@ -785,7 +796,7 @@ class ShowTable(TableAction):
     use_param_panel = True
     show_in_workflow = False
     opens_a_window = True
-    window_type = "t"
+    window_type = constants.WINDOW_TYPE_TABLE
     action_name = "grid"
     select_rows = False
     callable_from = None
@@ -809,7 +820,7 @@ class ShowDetail(Action):
     icon_name = "application_form"
     ui5_icon_name = "sap-icon://detail-view"
     opens_a_window = True
-    window_type = "d"
+    window_type = constants.WINDOW_TYPE_DETAIL
     show_in_workflow = False
     save_action_name = "submit_detail"
     callable_from = "t"
@@ -893,7 +904,7 @@ class ShowInsert(TableAction):
     show_in_workflow = False
     show_in_side_toolbar = True
     opens_a_window = True
-    window_type = "i"
+    window_type = constants.WINDOW_TYPE_INSERT
     hide_navigator = True  # 20210509
     hide_top_toolbar = True  # 20210509
     sort_index = 10
@@ -1342,11 +1353,7 @@ class DeleteSelected(MultipleRowAction):
     sort_index = 30
     readonly = False
     show_in_workflow = False
-    # required_roles = set([SiteUser])
-    # ~ callable_from = (ShowTable,ShowDetail)
-    # ~ needs_selection = True
     label = _("Delete")
-    # ~ url_action_name = 'delete'
     hotkey = keyboard.DELETE  # (ctrl=True)
 
     # ~ client_side = True

lino/core/actors.py

@@ -27,10 +27,11 @@ from lino.utils import MissingRow
 from lino.core import fields
 from lino.core import actions
 from lino.core import layouts
+from lino.core import constants
 from lino.core.requests import ActionRequest
 from lino.core.boundaction import BoundAction
 from lino.core.exceptions import ChangedAPI
-from lino.core.constants import _handle_attr_name, CHOICES_BLANK_FILTER_VALUE
+from lino.core.constants import _handle_attr_name
 from lino.core.permissions import add_requirements, Permittable
 from lino.core.utils import resolve_model
 from lino.core.utils import error2str
@@ -291,7 +292,17 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
     # """
 
     only_fields = None
-    display_mode = None
+
+    default_display_modes = None
+
+    # extra_display_modes = set()
+    # extra_display_modes = {constants.DISPLAY_MODE_SUMMARY}
+    extra_display_modes = {constants.DISPLAY_MODE_HTML}
+    """
+    A set of additional display modes to make available when rendering this table.
+
+    See :ref:`dg.dd.table.extra_display_modes`.
+    """
 
     app_label = None
     """
@@ -428,6 +439,7 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
     default_action = None
     actor_id = None
 
+    grid_layout = None
     detail_layout = None
     insert_layout = None
     card_layout = None
@@ -730,8 +742,12 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
 
         if hasattr(cls, "required"):
             raise ChangedAPI(
-                "{0} must convert `required` to `required_roles`".format(cls)
+                f"{cls} must convert `required` to `required_roles`"
             )
+        if hasattr(cls, "display_mode"):
+            # cls.default_display_modes = {k:v for k, v in cls.display_mode}
+            # logger.info(f"{cls} uses deprecated `display_mode`, please convert to `default_display_modes`.")
+            raise ChangedAPI(f"{cls} must convert `display_mode` to `default_display_modes`")
 
         master = getattr(cls, "master", None)
         if isinstance(master, str):
@@ -760,6 +776,45 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
                     cls.virtual_fields["detail_link"] = de
                     # cls.add_virtual_field('detail_link', de)
 
+        if cls.abstract:
+            return
+
+        edm = set()  # extra display modes to add automatically
+        if cls.default_display_modes is not None:
+            for v in cls.default_display_modes.values():
+                if v not in constants.DISPLAY_MODES:
+                    raise Exception(f"Invalid display mode {v} in {cls}")
+                if v not in constants.BASIC_DISPLAY_MODES:
+                    # be sure to have our copy the extra_display_modes set
+                    # if str(cls) == "comments.Comments":
+                    #     print(f"20240929 extra_display_modes is {cls.extra_display_modes}, we add {v}")
+                    # cls.extra_display_modes = cls.extra_display_modes | {v}
+                    edm.add(v)
+
+        if cls.card_layout is not None:
+            edm.add(constants.DISPLAY_MODE_CARDS)
+        if 'row_as_paragraph' in cls.__dict__:
+            edm.add(constants.DISPLAY_MODE_LIST)
+        # if 'row_as_page' in cls.__dict__:
+        #     edm.add(constants.DISPLAY_MODE_STORY)
+        if model is not None:
+            if model.extra_display_modes is not None:
+                for v in model.extra_display_modes:
+                    if v not in constants.DISPLAY_MODES:
+                        raise Exception(f"Invalid display mode {v} in {model}.extra_display_modes")
+                edm |= model.extra_display_modes
+            if 'as_paragraph' in model.__dict__:
+                edm.add(constants.DISPLAY_MODE_LIST)
+            if 'as_page' in model.__dict__:
+                edm.add(constants.DISPLAY_MODE_STORY)
+            # no need to automatically add summary because it's in default_display_modes of every table
+            # if 'as_summary_item' in model.__dict__:
+            #     edm.add(constants.DISPLAY_MODE_SUMMARY)
+        if len(edm) > 0:
+            # if str(cls) == "comments.Comments":
+            #     print(f"20240929 {cls} extra_display_modes add {edm}")
+            cls.extra_display_modes = cls.extra_display_modes | edm
+
     @classmethod
     def init_layouts(cls):
         # 20200430 this was previously part of class_init, but is now called in
@@ -1238,7 +1293,7 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
                 yield t
         for k in self.simple_parameters:
             v = getattr(ar.param_values, k)
-            if v and v != CHOICES_BLANK_FILTER_VALUE:
+            if v and v != constants.CHOICES_BLANK_FILTER_VALUE:
                 if v is True:
                     # For BooleanField no need to add "True" in the title
                     yield str(self.parameters[k].verbose_name)
@@ -1605,10 +1660,10 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
         return wl.get_layout_handle()
 
     @classmethod
-    def get_list_layout(cls, *args):
+    def get_grid_layout(cls, *args):
         assert cls.default_action is not None
         ah = cls.get_handle()
-        return ah.get_list_layout()
+        return ah.get_grid_layout()
 
     @classmethod
     def get_detail_elems(cls):
@@ -1831,6 +1886,25 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
         # assert_safe(html_text)  # temporary 20240506
         return format_html(DIVTPL, html_text)
 
+    @classmethod
+    def get_table_story(cls, obj, ar):
+        sar = cls.request(parent=ar, master_instance=obj, is_on_main_actor=False)
+        html = mark_safe("")
+        for i, obj in enumerate(sar.data_iterator):
+            if i == cls.preview_limit:
+                break
+            s = obj.as_story_item(sar)
+            # assert_safe(s)  # temporary 20240506
+            html += s
+        if cls.insert_action is not None:
+            if not cls.editable:
+                return html
+            ir = cls.insert_action.request_from(sar)
+            if ir.get_permission():
+                html = tostring(ir.ar2button()) + html
+        # assert_safe(html)  # temporary 20240506
+        return html
+
     @classmethod
     def get_table_summary(cls, obj, ar):
         """
@@ -1892,7 +1966,7 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
         if ar is None:
             return str(self)
         # cols = ar.actor.get_detail_layout().main
-        cols = cls.get_list_layout().main.columns
+        cols = cls.get_grid_layout().main.columns
         cols = [c for c in cols if not c.value.get("hidden")]
         if fmt is None:
 
@@ -1914,7 +1988,7 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
         values = [v for v in values if v is not None]
         s = ", ".join(values)
         # s = str(ar.actor)
-        # print("20231218", s)  # self, ar.actor.get_list_layout().main.columns)
+        # print("20231218", s)  # self, ar.actor.get_grid_layout().main.columns)
         return s
 
     @classmethod

lino/core/constants.py

@@ -47,22 +47,38 @@ URL_PARAM_WINDOW_TYPE = "wt"
 
 WINDOW_TYPE_TABLE = "t"
 WINDOW_TYPE_DETAIL = "d"
-WINDOW_TYPE_CARDS = "c"
-WINDOW_TYPE_GALLERIA = "g"
 WINDOW_TYPE_INSERT = "i"
 WINDOW_TYPE_PARAMS = "p"
 
+WINDOW_TYPES = {
+    WINDOW_TYPE_TABLE, WINDOW_TYPE_DETAIL, WINDOW_TYPE_INSERT,
+    WINDOW_TYPE_PARAMS
+}
+
 URL_PARAM_DISPLAY_MODE = "dm"
 
-DISPLAY_MODE_TABLE = "grid"  # deprecated
 DISPLAY_MODE_GRID = "grid"
 DISPLAY_MODE_DETAIL = "detail"
+DISPLAY_MODE_HTML = "html"
 DISPLAY_MODE_SUMMARY = "summary"
 DISPLAY_MODE_LIST = "list"
 DISPLAY_MODE_CARDS = "cards"
 DISPLAY_MODE_GALLERY = "gallery"
 DISPLAY_MODE_STORY = "story"
-DISPLAY_MODE_HTML = "html"
+
+DISPLAY_MODES = {
+    DISPLAY_MODE_GRID,
+    DISPLAY_MODE_DETAIL,
+    DISPLAY_MODE_HTML,
+    DISPLAY_MODE_SUMMARY,
+    DISPLAY_MODE_LIST,
+    DISPLAY_MODE_CARDS,
+    DISPLAY_MODE_GALLERY,
+    DISPLAY_MODE_STORY}
+
+BASIC_DISPLAY_MODES = {
+    DISPLAY_MODE_GRID,
+    DISPLAY_MODE_DETAIL}
 
 # ~ URL_PARAM_EUSER = 'euser'
 # ~ URL_PARAM_EUSER = 'su'

lino/core/dashboard.py

@@ -74,9 +74,7 @@ class DashboardItem(Permittable):
         assert sar.renderer is not None
         if isinstance(sar, TableRequest):
             # TODO 20220930 until now, dashboard was always acting as if
-            # display_mode was DISPLAY_MODE_TABLE
-            # if sar.actor.display_mode == constants.DISPLAY_MODE_TABLE
-
+            # display_mode was DISPLAY_MODE_GRID
             for e in sar.renderer.table2story(sar, **kwargs):
                 # assert_safe(tostring(e))
                 yield tostring(e)

lino/core/dbtables.py

@@ -212,7 +212,6 @@ class Table(AbstractTable):
 
     @classmethod
     def init_layouts(cls):
-        # if cls.list_layout is None:
         if cls.model is not None and issubclass(cls.model, Model):
             if not cls.abstract:
                 for tbl in cls.__mro__:
@@ -222,7 +221,7 @@ class Table(AbstractTable):
                     if issubclass(tbl, actors.Actor):
                         cls.list_layout = "list_item"
                         break
-        super(Table, cls).init_layouts()
+        super().init_layouts()
 
     @classmethod
     def add_quick_search_filter(cls, qs, search_text):
@@ -237,7 +236,7 @@ class Table(AbstractTable):
 
     @classmethod
     def get_chooser_for_field(self, fieldname):
-        ch = super(Table, self).get_chooser_for_field(fieldname)
+        ch = super().get_chooser_for_field(fieldname)
         if ch is not None:
             return ch
         if self.model is not None:
@@ -292,7 +291,7 @@ class Table(AbstractTable):
             for ds in yield_model_detail_sets(self.model):
                 yield ds
 
-        for s in super(Table, self).get_detail_sets():
+        for s in super().get_detail_sets():
             yield s
 
     # @classmethod
@@ -302,25 +301,6 @@ class Table(AbstractTable):
     # return vf
     # return cls.model._meta.get_field(name)
 
-    @classmethod
-    def get_table_story(cls, obj, ar):
-        sar = cls.request(parent=ar, master_instance=obj, is_on_main_actor=False)
-        html = mark_safe("")
-        for i, obj in enumerate(sar.data_iterator):
-            if i == cls.preview_limit:
-                break
-            s = obj.as_story_item(sar)
-            # assert_safe(s)  # temporary 20240506
-            html += s
-        if cls.insert_action is not None:
-            if not cls.editable:
-                return html
-            ir = cls.insert_action.request_from(sar)
-            if ir.get_permission():
-                html = tostring(ir.ar2button()) + html
-        # assert_safe(html)  # temporary 20240506
-        return html
-
     @classmethod
     def get_pk_field(self):
         return self.model._meta.pk
@@ -334,18 +314,22 @@ class Table(AbstractTable):
         Note: `ar` may not be None.
 
         """
-        return self.model.objects.get(pk=pk)
+        # return self.model.objects.get(pk=pk)
+        # raise Exception("20240929")
+        qs = self.get_request_queryset(ar)
         # qs = self.model.get_request_queryset(ar)
+
+        return qs.get(pk=pk)
         # try:
         #     return qs.get(pk=pk)
         #     # return self.get_queryset(ar).get(pk=pk)
         # except ValueError:
         #     return None
         # except self.model.DoesNotExist:
-        #     # import sqlparse
-        #     # sql = str(qs.query).replace('"', '')
-        #     # sql = sqlparse.format(sql, reindent=True, keyword_case='upper')
-        #     # raise Exception("20240324 {}, {}".format(ar.param_values, sql))
+        #     import sqlparse
+        #     sql = str(qs.query).replace('"', '')
+        #     sql = sqlparse.format(sql, reindent=True, keyword_case='upper')
+        #     raise Exception("20240324 {}, {}".format(ar.param_values, sql))
         #     return None
 
     # @classmethod
@@ -520,7 +504,7 @@ class Table(AbstractTable):
                     self.master_field = fk
                     # self.hidden_columns |= set([fk.name])
 
-        super(Table, self).class_init()
+        super().class_init()
 
         if self.order_by is not None:
             if not isinstance(self.order_by, (list, tuple)):
@@ -547,7 +531,7 @@ class Table(AbstractTable):
 
     @classmethod
     def do_setup(self):
-        super(Table, self).do_setup()
+        super().do_setup()
         # AbstractTable.do_setup(self)
         if self.model is None:
             return
@@ -567,7 +551,7 @@ class Table(AbstractTable):
 
     @classmethod
     def make_disabled_fields(cls, obj, ar):
-        s = super(Table, cls).make_disabled_fields(obj, ar)
+        s = super().make_disabled_fields(obj, ar)
 
         if obj is not None and ar is not None:
             s |= obj.disabled_fields(ar)
@@ -605,8 +589,7 @@ class Table(AbstractTable):
         if self.delete_action is None:
             return "No delete_action"
         if not self.get_row_permission(
-            obj, ar, self.get_row_state(obj), self.delete_action
-        ):
+            obj, ar, self.get_row_state(obj), self.delete_action):
             # print "20130222 ar is %r" % ar
             # logger.info("20130225 dbtables.disable_delete no permission")
             return _("You have no permission to delete this row.")
@@ -634,23 +617,23 @@ class Table(AbstractTable):
                 qs = qs.exclude(**ar.exclude)
                 # qs = qs.exclude(ar.exclude)
 
-            # 20200425
-            spv = dict()
-            for k in self.simple_parameters:
-                v = getattr(ar.param_values, k)
-                # if "room" in k:
-                # print("20200423", k, v, self.simple_parameters, ar.param_values)
-                if v == constants.CHOICES_BLANK_FILTER_VALUE:
-                    spv[k + "__isnull"] = True
-                elif v == constants.CHOICES_NOT_BLANK_FILTER_VALUE:
-                    spv[k + "__isnull"] = False
-                elif v is not None:
-                    spv[k] = v
-                    # print("20240506 {} = {}".format(k, v))
-                    ar.known_values[k] = v  # make it an obvious field
-
-            qs = self.model.add_param_filter(qs, **spv)
-            # qs = self.model.add_param_filter(qs, **ar.param_values)
+            if ar.param_values is not None:
+                spv = dict()
+                for k in self.simple_parameters:
+                    v = getattr(ar.param_values, k)
+                    # if "room" in k:
+                    # print("20200423", k, v, self.simple_parameters, ar.param_values)
+                    if v == constants.CHOICES_BLANK_FILTER_VALUE:
+                        spv[k + "__isnull"] = True
+                    elif v == constants.CHOICES_NOT_BLANK_FILTER_VALUE:
+                        spv[k + "__isnull"] = False
+                    elif v is not None:
+                        spv[k] = v
+                        # print("20240506 {} = {}".format(k, v))
+                        ar.known_values[k] = v  # make it an obvious field
+
+                qs = self.model.add_param_filter(qs, **spv)
+                # qs = self.model.add_param_filter(qs, **ar.param_values)
 
             if self.filter:
                 qs = qs.filter(self.filter)

lino/core/elems.py

@@ -854,11 +854,11 @@ class TextFieldElement(FieldElement):
 
     def get_field_options(self, **kw):
         kw = super().get_field_options(**kw)
-        if isinstance(self.field, fields.VirtualField) and self.field.simple_elem:
-            kw["virtualField"] = True
-            kw["noHeaderDecore"] = True
-            kw["noEditorHeader"] = True
-            kw["alwaysEditable"] = True
+        # if isinstance(self.field, fields.VirtualField) and self.field.simple_elem:
+        #     kw["virtualField"] = True
+        #     kw["noHeaderDecore"] = True
+        #     kw["noEditorHeader"] = True
+        #     kw["alwaysEditable"] = True
         kw["format"] = self.format
         return kw
 
@@ -2311,8 +2311,8 @@ class Panel(Container):
 
 
 class GridElement(Container):
-    """Represents a Lino.GridPanel, i.e. the widget used to represent a
-    table or a slave table.
+    """Represents a Lino.GridPanel, i.e. the widget used to render a
+    table in :term:`grid mode`.
 
     """
 
@@ -2343,14 +2343,13 @@ class GridElement(Container):
         self.actor = rpt
         if len(columns) == 0:
             self.rh = rpt.get_handle()
-            if not hasattr(self.rh, "list_layout"):
+            if not hasattr(self.rh, "grid_layout"):
                 raise Exception(
-                    "Handle for {0} (model {1}) has no list_layout".format(
+                    "Handle for {0} (model {1}) has no grid_layout".format(
                         rpt, rpt.model
                     )
                 )
-            columns = self.rh.list_layout.main.columns
-            # columns = self.rh.list_layout._main.elements
+            columns = self.rh.grid_layout.main.columns
         w = 0
         for e in columns:
             w += e.width or e.preferred_width
@@ -2433,20 +2432,15 @@ class SlaveContainer(GridElement):
     slaves = None
 
     def __init__(self, layout_handle, name, rpt, *columns, **kw):
-        dms = [dm[1] for dm in rpt.display_mode]
         slaves = dict()
-        if constants.DISPLAY_MODE_STORY in dms:
+        if constants.DISPLAY_MODE_STORY in rpt.extra_display_modes:
             slaves["story"] = get_story_element(layout_handle, rpt, name, **kw)
-        if constants.DISPLAY_MODE_LIST in dms:
+        if constants.DISPLAY_MODE_LIST in rpt.extra_display_modes:
             slaves["list"] = get_list_element(layout_handle, rpt, name, **kw)
-        # if constants.DISPLAY_MODE_HTML in dms:
-        #     slaves["html"] = get_htmlbox_element(layout_handle, rpt, name, **kw)
-        # if constants.DISPLAY_MODE_SUMMARY in dms:
-        #     slaves["summary"] = get_summary_element(layout_handle, rpt, name, **kw)
-        # slaves["story"] = get_story_element(layout_handle, rpt, name, **kw)
-        # slaves["list"] = get_list_element(layout_handle, rpt, name, **kw)
-        slaves["html"] = get_htmlbox_element(layout_handle, rpt, name, **kw)
-        slaves["summary"] = get_summary_element(layout_handle, rpt, name, **kw)
+        if constants.DISPLAY_MODE_SUMMARY in rpt.extra_display_modes:
+            slaves["summary"] = get_summary_element(layout_handle, rpt, name, **kw)
+        if constants.DISPLAY_MODE_HTML in rpt.extra_display_modes:
+            slaves["html"] = get_htmlbox_element(layout_handle, rpt, name, **kw)
         if slaves:
             self.slaves = slaves
         super().__init__(layout_handle, name, rpt, *columns, **kw)
@@ -2845,13 +2839,11 @@ def create_layout_element(lh, name, **kw):
 
         # print("20240317", de, lh)
         if isinstance(lh.layout, FormLayout):
-            # When a table is specified in the layout of a
-            # DetailWindow, then it will be rendered as a panel that
-            # displays a "summary" of that table. The panel will have
-            # a tool button to "open that table in its own
-            # window". The format of that summary is defined by the
-            # `display_mode` of the table.
-
+            # When a table is specified in the layout of a DetailWindow, then it
+            # will be rendered as a :term:`slave panel`. The panel will have a
+            # tool button to "open that table in its own window". The display
+            # mode of that summary is defined by the `default_display_modes` of
+            # the table.
             if lh.ui.renderer.extjs_version is not None:
                 if de.label is not None:
                     js = (
@@ -2871,17 +2863,18 @@ def create_layout_element(lh, name, **kw):
                     kw.update(label="{} {}".format(de.get_label(), tostring(btn)))
 
             if (
-                len(de.display_mode) > 1
+                len(de.default_display_modes) > 1
                 and lh.ui.renderer.front_end.media_name == "react"
             ):
+                # print(f"20240928 {de} in {lh} gets SlaveContainer")
                 return SlaveContainer(lh, name, de, **kw)
 
             dm = de.get_display_mode()
-            if dm in [
-                constants.DISPLAY_MODE_TABLE,
+            if dm in {
+                constants.DISPLAY_MODE_GRID,
                 constants.DISPLAY_MODE_CARDS,
                 constants.DISPLAY_MODE_GALLERY
-            ]:
+            }:
                 kw.update(hide_top_toolbar=True)
                 if de.preview_limit is not None:
                     kw.update(preview_limit=de.preview_limit)

lino/core/fields.py

@@ -322,7 +322,7 @@ class FakeField(object):
             setattr(self, k, v)
 
     def __repr__(self):
-        # copied from django Field 
+        # copied from django Field
         path = "%s.%s" % (self.__class__.__module__, self.__class__.__qualname__)
         name = getattr(self, "name", None)
         if name is not None:
@@ -561,10 +561,10 @@ class VirtualField(FakeField):
     (because they inherit from that class).
     """
 
-    simple_elem = False
-    """
-    Used in :meth:`get_field_options` to set :term:`front end` rendering options.
-    """
+    # simple_elem = False
+    # """
+    # Used in :meth:`get_field_options` to set :term:`front end` rendering options.
+    # """
 
     def __init__(self, return_type, get=return_none, **kwargs):
         """
@@ -579,7 +579,7 @@ class VirtualField(FakeField):
         self.return_type = return_type  # a Django Field instance
         self.get = get
 
-        self.simple_elem = kwargs.get("simple_elem", self.simple_elem)
+        # self.simple_elem = kwargs.get("simple_elem", self.simple_elem)
 
         # if isinstance(return_type, FakeField):
         #     sortable_by = return_type.sortable_by
@@ -1217,6 +1217,12 @@ class TableRow(object):
 
     _lino_default_table = None
     _widget_options = {}
+    extra_display_modes = None
+    """
+    A set of extra display modes to make available on actors that use this model.
+
+    See :ref:`dg.dd.table.extra_display_modes`.
+    """
 
     pk = None
 
@@ -1363,7 +1369,7 @@ class TableRow(object):
         return tostring(self.as_summary_item(ar, **kwargs))
 
     def as_story_item(self, ar, **kwargs):
-        kwargs.update(display_mode="story")
+        kwargs.update(display_mode=constants.DISPLAY_MODE_STORY)
         return mark_safe("".join(self.as_page(ar, **kwargs)))
 
     def as_page(self, ar, **kwargs):