diff --git a/CHANGES.rst b/CHANGES.rst
index 97d929fb..4b48d841 100644
--- a/CHANGES.rst
+++ b/CHANGES.rst
@@ -5,7 +5,16 @@ Changelog
 1.4.56 (unreleased)
 -------------------
 
-- Nothing changed yet.
+- WEBBDC-2835: REFACTOR : Move the contact-section row schemas, row helpers, grid form
+  mixin, frozen-label widget and ``*DisplayColumns`` vocabularies to
+  ``imio.smartweb.common`` so ``events`` and ``news`` can reuse them.
+  [boulch]
+
+- WEBBDC-2835: Add read-only phones/mails/urls datagrids to the contact section,
+  loaded from the related contacts with a dedicated button, with a per-row
+  checkbox column choosing which columns are displayed. Unchecking every column
+  hides the row.
+  [boulch]
 
 
 1.4.55 (2026-07-28)
diff --git a/base.cfg b/base.cfg
index bb54f922..00d63bb3 100644
--- a/base.cfg
+++ b/base.cfg
@@ -67,6 +67,5 @@ scripts =
 # Don't use a released version of imio.smartweb.core
 imio.smartweb.core =
 
-[remotes]
-imio = https://github.com/IMIO
-imio_push = git@github.com:IMIO
+[sources]
+imio.smartweb.common = git https://github.com/IMIO/imio.smartweb.common.git pushurl=git@github.com:IMIO/imio.smartweb.common.git branch=WEBBDC-2835
\ No newline at end of file
diff --git a/src/imio/smartweb/core/contents/sections/contact/content.py b/src/imio/smartweb/core/contents/sections/contact/content.py
index b9c327dc..bf3bd9ca 100644
--- a/src/imio/smartweb/core/contents/sections/contact/content.py
+++ b/src/imio/smartweb/core/contents/sections/contact/content.py
@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 
+from imio.smartweb.common.contact.rows import IContactInformationsGrids
 from imio.smartweb.common.widgets.select import TranslatedAjaxSelectWidget
 from imio.smartweb.core.contents.sections.base import ISection
 from imio.smartweb.core.contents.sections.base import Section
@@ -11,8 +12,14 @@
 from zope.interface import implementer
 
 
-class ISectionContact(ISection):
-    """Marker interface and Dexterity Python Schema for SectionContact"""
+class ISectionContact(ISection, IContactInformationsGrids):
+    """Marker interface and Dexterity Python Schema for SectionContact
+
+    The `contact_informations` fieldset and its three read-only datagrids come
+    from IContactInformationsGrids, shared with imio.events.core. Here the
+    stored data columns are RESIDUE: the page render always re-reads the live
+    directory payload and only `visible_columns` is authoritative.
+    """
 
     directives.widget(
         "related_contacts",
diff --git a/src/imio/smartweb/core/contents/sections/contact/forms.py b/src/imio/smartweb/core/contents/sections/contact/forms.py
index 4b3bea5d..fc1b6840 100644
--- a/src/imio/smartweb/core/contents/sections/contact/forms.py
+++ b/src/imio/smartweb/core/contents/sections/contact/forms.py
@@ -1,17 +1,33 @@
 # -*- coding: utf-8 -*-
 
 from imio.smartweb.common.browser.forms import CustomAddForm
+from imio.smartweb.common.contact.forms import ContactInformationsGridMixin
 from imio.smartweb.core.browser.forms import SmartwebCustomEditForm
+from imio.smartweb.locales import SmartwebMessageFactory as _
 from plone.dexterity.browser.add import DefaultAddView
 from plone.z3cform import layout
+from z3c.form import button
 from z3c.form.interfaces import HIDDEN_MODE
 
 
-class ContactCustomAddForm(CustomAddForm):
-    portal_type = "imio.smartweb.SectionContact"
+class SectionContactGridMixin(ContactInformationsGridMixin):
+    """The section's own bits: `related_contacts` and the hidden hide_title.
+
+    The grid-reloading machinery itself lives in
+    imio.smartweb.common.contact.forms, shared with imio.events.core.
+
+    `hide_title` is hidden after the widgets exist, which both concrete forms
+    need and neither may forget. It belongs to the Section base and does not
+    exist outside one, which is why it is not in the shared mixin.
+    """
+
+    contact_uids_field = "related_contacts"
 
     def update(self):
-        super(ContactCustomAddForm, self).update()
+        super().update()
+        self._hide_hide_title()
+
+    def _hide_hide_title(self):
         # We hide hide_title field so no one can change the value for contact
         # and set True value (single checkbox)
         for group in self.groups:
@@ -20,19 +36,39 @@ def update(self):
                 group.widgets["hide_title"].value = ["selected"]
 
 
+class ContactCustomAddForm(SectionContactGridMixin, CustomAddForm):
+    portal_type = "imio.smartweb.SectionContact"
+
+    # Both MUST be copied before the decorator runs: @buttonAndHandler does a
+    # setdefault on the `buttons` AND on the `handlers` name of the class body
+    # being defined. Without the copies it would create fresh, empty managers
+    # that shadow the base ones -- the form would lose the Save / Cancel
+    # buttons (buttons) and, more silently, their handlers (handlers), so
+    # pressing Save would render the form again without saving anything.
+    buttons = CustomAddForm.buttons.copy()
+    handlers = CustomAddForm.handlers.copy()
+
+    @button.buttonAndHandler(
+        _("Load contact information"), name="load_contact_informations"
+    )
+    def handleLoadContactInformations(self, action):
+        """No-op: the grids were already rebuilt in update()."""
+
+
 class ContactCustomAddView(DefaultAddView):
     form = ContactCustomAddForm
 
 
-class ContactCustomEditForm(SmartwebCustomEditForm):
-    def update(self):
-        super(ContactCustomEditForm, self).update()
-        # We hide hide_title field so no one can change the value for contact
-        # and set True value (single checkbox)
-        for group in self.groups:
-            if group.__name__ == "layout":
-                group.widgets["hide_title"].mode = HIDDEN_MODE
-                group.widgets["hide_title"].value = ["selected"]
+class ContactCustomEditForm(SectionContactGridMixin, SmartwebCustomEditForm):
+    # See ContactCustomAddForm for why both managers are copied here.
+    buttons = SmartwebCustomEditForm.buttons.copy()
+    handlers = SmartwebCustomEditForm.handlers.copy()
+
+    @button.buttonAndHandler(
+        _("Load contact information"), name="load_contact_informations"
+    )
+    def handleLoadContactInformations(self, action):
+        """No-op: the grids were already rebuilt in update()."""
 
 
 ContactCustomEditView = layout.wrap_form(ContactCustomEditForm)
diff --git a/src/imio/smartweb/core/contents/sections/contact/macros.pt b/src/imio/smartweb/core/contents/sections/contact/macros.pt
index 8274a70c..7cb11c88 100644
--- a/src/imio/smartweb/core/contents/sections/contact/macros.pt
+++ b/src/imio/smartweb/core/contents/sections/contact/macros.pt
@@ -51,8 +51,17 @@
                tal:content="subtitle"></div>
         </div>
 
+        <tal:informations tal:condition="python:'contact_informations' in visible_blocks">
+        <!-- The defines MUST live on a nested element: TAL evaluates `define`
+             BEFORE `condition` on the same element, so keeping them on
+             <tal:informations> would consult the grids even when the block is
+             unchecked. -->
+        <tal:def tal:define="phone_entries python:contact.displayed_rows('phones');
+                             mail_entries python:contact.displayed_rows('mails');
+                             url_entries python:contact.displayed_rows('urls');
+                             vat_number python:contact.vat_number">
         <div class="contact_informations"
-             tal:condition="python:'contact_informations' in visible_blocks">
+             tal:condition="python:phone_entries or mail_entries or url_entries or vat_number">
 
           <h2 class="informations"
               tal:condition="not: show_main_title"
@@ -61,34 +70,70 @@
               tal:condition="show_main_title"
               i18n:translate="">Contact</h3>
 
-          <span tal:replace="python:contact.vat_number"></span>
+          <span tal:condition="vat_number" tal:replace="vat_number"></span>
           <ul class="contact_informations_genral"
-              tal:define="phones python:contact.phones;
-                          mails python:contact.mails">
-            <li class="phones"
-                tal:repeat="phone phones"
-                tal:attributes="class python:phone.get('type') or ''">
-              <span tal:replace="python:phone.get('label') or ''"></span>
-              <a tal:attributes="href python:'tel:{}'.format(phone.get('number'))"
-                 tal:content="python:'{}'.format(phone.get('number'))" />
-            </li>
-            <li class="mails"
-                tal:repeat="mail mails"
-                tal:attributes="class python:mail.get('type') or ''">
-              <span tal:replace="python:'{}'.format(mail.get('label') or '')"></span>
-              <a tal:attributes="href  python:'mailto:{}'.format(mail.get('mail_address'))"
-                 tal:content="python:'{}'.format(mail.get('mail_address'))" />
-            </li>
+              tal:condition="python:phone_entries or mail_entries">
+            <tal:phone tal:repeat="entry phone_entries">
+              <li tal:define="phone entry/data; columns entry/columns"
+                  tal:attributes="class python:phone.get('type') or ''">
+                <span tal:condition="python:'label' in columns"
+                      tal:replace="python:phone.get('label') or ''"></span>
+                <span tal:condition="python:'type' in columns"
+                      tal:replace="python:contact.translated_type('phones', phone.get('type'))"></span>
+                <a tal:condition="python:'number' in columns"
+                   tal:attributes="href python:'tel:{}'.format(phone.get('number'))"
+                   tal:content="python:'{}'.format(phone.get('number'))" />
+              </li>
+            </tal:phone>
+            <tal:mail tal:repeat="entry mail_entries">
+              <li tal:define="mail entry/data; columns entry/columns"
+                  tal:attributes="class python:mail.get('type') or ''">
+                <span tal:condition="python:'label' in columns"
+                      tal:replace="python:mail.get('label') or ''"></span>
+                <span tal:condition="python:'type' in columns"
+                      tal:replace="python:contact.translated_type('mails', mail.get('type'))"></span>
+                <a tal:condition="python:'mail_address' in columns"
+                   tal:attributes="href python:'mailto:{}'.format(mail.get('mail_address'))"
+                   tal:content="python:'{}'.format(mail.get('mail_address'))" />
+              </li>
+            </tal:mail>
           </ul>
           <ul class="contact_informations_social"
-              tal:define="urls python:contact.get_urls"
-              tal:condition="urls">
-            <li class="urls"
-                tal:repeat="url urls"
-                tal:attributes="class python:url.get('type') or ''">
-              <a tal:attributes="href python:url.get('url');
-                                 title python:contact.get_translated_url_type(url.get('type'))"
-                target="_blank">
+              tal:condition="url_entries">
+            <tal:url tal:repeat="entry url_entries">
+              <li tal:define="url entry/data; columns entry/columns"
+                  tal:attributes="class python:url.get('type') or ''">
+                <a tal:condition="python:'url' in columns"
+                   tal:attributes="href python:url.get('url');
+                                   title python:contact.get_translated_url_type(url.get('type')) if ('type' in columns and url.get('type')) else nothing"
+                   target="_blank">
+                    <tal:icon tal:condition="python:'type' in columns">
+                      <tal:condition tal:condition="python:url.get('type') == 'facebook'">
+                          <i class="bi bi-facebook"></i>
+                      </tal:condition>
+                      <tal:condition tal:condition="python:url.get('type') == 'twitter'">
+                          <i class="bi bi-twitter"></i>
+                      </tal:condition>
+                      <tal:condition tal:condition="python:url.get('type') == 'instagram'">
+                          <i class="bi bi-instagram"></i>
+                      </tal:condition>
+                      <tal:condition tal:condition="python:url.get('type') == 'youtube'">
+                        <i class="bi bi-youtube"></i>
+                      </tal:condition>
+                      <tal:condition tal:condition="python:url.get('type') == 'pinterest'">
+                          <i class="bi bi-pinterest"></i>
+                      </tal:condition>
+                      <tal:condition tal:condition="python:url.get('type') == 'linkedin'">
+                          <i class="bi bi-linkedin"></i>
+                      </tal:condition>
+                    </tal:icon>
+                    <span tal:attributes="class python:'sr-only' if url.get('type') != 'website' else ''"
+                          tal:content="python:url.get('url')"/>
+                </a>
+                <!-- Type checked, Url unchecked: the editor still asked for
+                     the icon, but there is no href to link, so render the
+                     icon on its own, not wrapped in an <a>. -->
+                <tal:icon_only tal:condition="python:'type' in columns and 'url' not in columns">
                   <tal:condition tal:condition="python:url.get('type') == 'facebook'">
                       <i class="bi bi-facebook"></i>
                   </tal:condition>
@@ -107,13 +152,13 @@
                   <tal:condition tal:condition="python:url.get('type') == 'linkedin'">
                       <i class="bi bi-linkedin"></i>
                   </tal:condition>
-
-                  <span tal:attributes="class python:'sr-only' if url.get('type') != 'website' else ''"
-                        tal:content="python:url.get('url')"/>
-              </a>
-            </li>
+                </tal:icon_only>
+              </li>
+            </tal:url>
           </ul>
         </div>
+        </tal:def>
+        </tal:informations>
         <div class="address"
              tal:define="address python:contact.formatted_address()"
              tal:condition="address">
diff --git a/src/imio/smartweb/core/contents/sections/contact/utils.py b/src/imio/smartweb/core/contents/sections/contact/utils.py
index e543a922..e1a2f0e2 100644
--- a/src/imio/smartweb/core/contents/sections/contact/utils.py
+++ b/src/imio/smartweb/core/contents/sections/contact/utils.py
@@ -1,5 +1,13 @@
 # -*- coding: utf-8 -*-
 
+from imio.smartweb.common.contact.directory import build_display_rows  # noqa: F401
+from imio.smartweb.common.contact.directory import displayed_rows as _displayed_rows
+from imio.smartweb.common.contact.directory import get_remote_contacts  # noqa: F401
+from imio.smartweb.common.contact.directory import row_key  # noqa: F401
+from imio.smartweb.common.contact.directory import translated_type_label
+from imio.smartweb.common.contact.directory import (
+    visible_columns_map as _visible_columns_map,
+)
 from imio.smartweb.common.contact_utils import ContactProperties as ContactSchedule
 from imio.smartweb.common.utils import get_term_from_vocabulary
 from imio.smartweb.common.utils import rich_description
@@ -12,6 +20,10 @@
 
 import json
 
+# build_display_rows, get_remote_contacts and row_key are re-exported rather
+# than used here: they moved to imio.smartweb.common but callers (the section
+# forms and the tests) still import them from this module.
+
 
 class ContactProperties(ContactSchedule):
     def __init__(self, json_dict, section):
@@ -139,6 +151,22 @@ def formatted_address(self):
             return None
         return {"street": street, "entity": entity, "country": country}
 
+    def translated_type(self, kind, token):
+        """Human label of a remote `type` token. See translated_type_label."""
+        return translated_type_label(kind, token)
+
+    def visible_columns_map(self, kind):
+        """See imio.smartweb.common.contact.directory.visible_columns_map."""
+        return _visible_columns_map(self.context, kind)
+
+    def displayed_rows(self, kind):
+        """See imio.smartweb.common.contact.directory.displayed_rows.
+
+        `self.contact` is the LIVE directory payload; the stored `*_display`
+        data columns are residue on this side and are never read here.
+        """
+        return _displayed_rows(self.contact, self.context, kind)
+
     @property
     def get_urls(self):
         if isinstance(self.urls, list):
diff --git a/src/imio/smartweb/core/tests/resources/json_contact_informations_raw_mock.json b/src/imio/smartweb/core/tests/resources/json_contact_informations_raw_mock.json
new file mode 100644
index 00000000..34bc6b90
--- /dev/null
+++ b/src/imio/smartweb/core/tests/resources/json_contact_informations_raw_mock.json
@@ -0,0 +1,64 @@
+{
+  "@id": "http://localhost:8080/Plone/@search",
+  "items": [
+    {
+      "@id": "http://localhost:8080/Plone/2dc381f0fb584381b8e4a19c84f53b35",
+      "@type": "imio.directory.Contact",
+      "UID": "2dc381f0fb584381b8e4a19c84f53b35",
+      "title": "Administration communale",
+      "subtitle": null,
+      "description": "",
+      "modified": "2026-07-29T08:00:00+00:00",
+      "type": {"token": "organization", "title": "Organization"},
+      "vat_number": null,
+      "street": "Rue de la Paix",
+      "number": "1",
+      "complement": null,
+      "zipcode": "4000",
+      "city": "Liege",
+      "country": {"token": "be", "title": "Belgique"},
+      "geolocation": {"latitude": 50.4, "longitude": 4.7},
+      "logo": null,
+      "image": null,
+      "is_geolocated": true,
+      "phones": [
+        {"label": "Secretariat", "type": "work", "number": "+3287123456"},
+        {"label": "Direction", "type": "cell", "number": "+32475010203"}
+      ],
+      "mails": [
+        {"label": "Accueil", "type": "work", "mail_address": "info@example.be"}
+      ],
+      "urls": [
+        {"type": "website", "url": "https://example.be"},
+        {"type": "facebook", "url": "https://facebook.com/example"}
+      ]
+    },
+    {
+      "@id": "http://localhost:8080/Plone/af7bd1f547034b24a2e0da16c0ba0358",
+      "@type": "imio.directory.Contact",
+      "UID": "af7bd1f547034b24a2e0da16c0ba0358",
+      "title": "CPAS",
+      "subtitle": null,
+      "description": "",
+      "modified": "2026-07-29T08:00:00+00:00",
+      "type": {"token": "organization", "title": "Organization"},
+      "vat_number": null,
+      "street": "Rue du Centre",
+      "number": "2",
+      "complement": null,
+      "zipcode": "4000",
+      "city": "Liege",
+      "country": {"token": "be", "title": "Belgique"},
+      "geolocation": {"latitude": 50.5, "longitude": 4.8},
+      "logo": null,
+      "image": null,
+      "is_geolocated": true,
+      "phones": [
+        {"label": "Accueil", "type": "work", "number": "+3287654321"}
+      ],
+      "mails": [],
+      "urls": []
+    }
+  ],
+  "items_total": 2
+}
diff --git a/src/imio/smartweb/core/tests/test_section_contact.py b/src/imio/smartweb/core/tests/test_section_contact.py
index 2c02b67d..708deced 100644
--- a/src/imio/smartweb/core/tests/test_section_contact.py
+++ b/src/imio/smartweb/core/tests/test_section_contact.py
@@ -6,7 +6,11 @@
 from freezegun import freeze_time
 from imio.smartweb.common.contact_utils import formatted_schedule
 from imio.smartweb.common.contact_utils import get_schedule_for_today
+from imio.smartweb.core.contents.sections.contact.utils import build_display_rows
 from imio.smartweb.core.contents.sections.contact.utils import ContactProperties
+from imio.smartweb.core.contents.sections.contact.utils import get_remote_contacts
+from imio.smartweb.core.contents.sections.contact.utils import row_key
+from imio.smartweb.core.contents.sections.contact.utils import translated_type_label
 from imio.smartweb.core.contents.sections.views import SECTION_ITEMS_HASH_KEY
 from imio.smartweb.core.tests.utils import clear_cache
 from imio.smartweb.core.testing import IMIO_SMARTWEB_CORE_FUNCTIONAL_TESTING
@@ -23,7 +27,9 @@
 from zope.annotation.interfaces import IAnnotations
 from zope.component import queryMultiAdapter
 
+import itertools
 import json
+import re
 import requests
 import requests_mock
 import transaction
@@ -84,7 +90,10 @@ def test_contact(self, m):
         self.assertEqual(json_contact.contact_type_class, "contact-type-organization")
         self.assertNotIn("contact_titles", view())
         self.assertIn("contact_address", view())
-        self.assertIn("contact_informations", view())
+        # The fixture's phones/mails/urls are empty and vat_number is null, so
+        # the contact informations block now has no content at all and is
+        # omitted (no more orphan title / empty <ul>).
+        self.assertNotIn("contact_informations", view())
         self.assertIn("schedule", view())
         self.assertNotIn("contact_gallery", view())
         contact.visible_blocks = ["titles", "gallery"]
@@ -93,7 +102,11 @@ def test_contact(self, m):
         self.assertNotIn("contact_informations", view())
         self.assertNotIn("schedule", view())
         contact.visible_blocks = ["contact_informations", "address", "schedule"]
-        self.assertEqual(view().count("<h2"), 4)
+        # Was 4: the section title <h2> plus one per block (informations,
+        # address, schedule). The informations block is now omitted (fixture
+        # has empty phones/mails/urls and a null vat_number), so only 3 remain
+        # (section title, address, schedule).
+        self.assertEqual(view().count("<h2"), 3)
         contact.visible_blocks = [
             "titles",
             "contact_informations",
@@ -102,8 +115,15 @@ def test_contact(self, m):
             "schedule",
         ]
         self.assertIn('class="pat-leaflet map"', view())
+        # Unchanged: the informations block's title was already an <h3> here
+        # (show_main_title is True), so its disappearance doesn't move this
+        # count -- these two <h2> are the section title and the contact's own
+        # title (contact_titles), untouched by this change.
         self.assertEqual(view().count("<h2"), 2)
-        self.assertEqual(view().count("<h3"), 3)
+        # Was 3: informations, address and schedule titles all rendered as
+        # <h3> (show_main_title True). The informations block is now omitted
+        # (empty fixture), leaving only address and schedule -> 2.
+        self.assertEqual(view().count("<h3"), 2)
 
         self.assertNotIn("contact_description", view())
         contact.visible_blocks = ["description"]
@@ -681,6 +701,219 @@ def test_contact_urls(self, m):
         self.assertNotIn('Error in section : "My contact"', view())
         self.assertIn("contact_informations_social", view())
 
+    def test_display_fields_exist_and_start_empty(self):
+        contact = api.content.create(
+            container=self.page,
+            type="imio.smartweb.SectionContact",
+            title="My contact",
+        )
+        for field_name in ("phones_display", "mails_display", "urls_display"):
+            self.assertIsNone(getattr(contact, field_name))
+
+    def test_display_fields_accept_rows(self):
+        contact = api.content.create(
+            container=self.page,
+            type="imio.smartweb.SectionContact",
+            title="My contact",
+        )
+        contact.phones_display = [
+            {
+                "contact_uid": "uid1",
+                "contact_title": "Administration communale",
+                "label": "Secretariat",
+                "type": "Work phone",
+                "number": "+3287123456",
+                "visible_columns": ["label", "number"],
+            }
+        ]
+        self.assertEqual(
+            contact.phones_display[0]["visible_columns"], ["label", "number"]
+        )
+
+    def test_display_grids_forbid_manual_row_editing(self):
+        # Rows come from the directory; an editor must not add or remove any.
+        from imio.smartweb.core.contents import ISectionContact
+        from plone.autoform.interfaces import WIDGETS_KEY
+        from plone.supermodel.utils import mergedTaggedValueDict
+
+        widgets = mergedTaggedValueDict(ISectionContact, WIDGETS_KEY)
+        for field_name in ("phones_display", "mails_display", "urls_display"):
+            factory = widgets[field_name]
+            self.assertFalse(factory.params["allow_insert"])
+            self.assertFalse(factory.params["allow_delete"])
+            self.assertFalse(factory.params["allow_reorder"])
+            self.assertFalse(factory.params["auto_append"])
+
+    @requests_mock.Mocker()
+    def test_displayed_columns_drive_the_render(self, m):
+        section = api.content.create(
+            container=self.page,
+            type="imio.smartweb.SectionContact",
+            title="My contact",
+        )
+        section.visible_blocks = ["contact_informations"]
+        uid = "2dc381f0fb584381b8e4a19c84f53b35"
+        section.related_contacts = [uid]
+        url = "http://localhost:8080/Plone/@search?UID={}&fullobjects=1".format(uid)
+        payload = get_json("resources/json_contact_informations_raw_mock.json")
+        payload["items"] = [payload["items"][0]]
+        m.get(url, text=json.dumps(payload))
+
+        view = queryMultiAdapter((self.page, self.request), name="full_view")
+        rendered = view()
+        self.assertIn("+3287123456", rendered)
+        self.assertIn("Secretariat", rendered)
+        self.assertIn("Work phone", rendered)
+
+        # Hide the label and the type of the first phone.
+        section.phones_display = [
+            {
+                "contact_uid": uid,
+                "number": "+3287123456",
+                "visible_columns": ["number"],
+            }
+        ]
+        sleep(1)
+        m.get(url, text=json.dumps(payload))
+        clear_cache(self.request)
+        rendered = queryMultiAdapter((self.page, self.request), name="full_view")()
+        self.assertIn("+3287123456", rendered)
+        self.assertNotIn("Secretariat", rendered)
+        # "Direction" is untouched, so its own label is still there.
+        self.assertIn("Direction", rendered)
+
+        # Uncheck every column: the row disappears entirely.
+        section.phones_display = [
+            {"contact_uid": uid, "number": "+3287123456", "visible_columns": []}
+        ]
+        sleep(1)
+        m.get(url, text=json.dumps(payload))
+        clear_cache(self.request)
+        rendered = queryMultiAdapter((self.page, self.request), name="full_view")()
+        self.assertNotIn("+3287123456", rendered)
+        self.assertIn("+32475010203", rendered)
+
+    @requests_mock.Mocker()
+    def test_no_empty_list_nor_orphan_title_when_everything_is_hidden(self, m):
+        section = api.content.create(
+            container=self.page,
+            type="imio.smartweb.SectionContact",
+            title="My contact",
+        )
+        section.visible_blocks = ["contact_informations"]
+        uid = "2dc381f0fb584381b8e4a19c84f53b35"
+        section.related_contacts = [uid]
+        url = "http://localhost:8080/Plone/@search?UID={}&fullobjects=1".format(uid)
+        payload = get_json("resources/json_contact_informations_raw_mock.json")
+        payload["items"] = [payload["items"][0]]
+        section.phones_display = [
+            {"contact_uid": uid, "number": "+3287123456", "visible_columns": []},
+            {"contact_uid": uid, "number": "+32475010203", "visible_columns": []},
+        ]
+        section.mails_display = [
+            {
+                "contact_uid": uid,
+                "mail_address": "info@example.be",
+                "visible_columns": [],
+            }
+        ]
+        section.urls_display = [
+            {"contact_uid": uid, "url": "https://example.be", "visible_columns": []},
+            {
+                "contact_uid": uid,
+                "url": "https://facebook.com/example",
+                "visible_columns": [],
+            },
+        ]
+        m.get(url, text=json.dumps(payload))
+        rendered = queryMultiAdapter((self.page, self.request), name="full_view")()
+        self.assertNotIn("contact_informations_genral", rendered)
+        self.assertNotIn("contact_informations_social", rendered)
+        self.assertNotIn('<h2 class="informations"', rendered)
+
+    @requests_mock.Mocker()
+    def test_contact_informations_unchecked_skips_the_grids(self, m):
+        # visible_blocks is the master switch: the DGFs are not even consulted.
+        section = api.content.create(
+            container=self.page,
+            type="imio.smartweb.SectionContact",
+            title="My contact",
+        )
+        section.visible_blocks = ["titles"]
+        uid = "2dc381f0fb584381b8e4a19c84f53b35"
+        section.related_contacts = [uid]
+        url = "http://localhost:8080/Plone/@search?UID={}&fullobjects=1".format(uid)
+        payload = get_json("resources/json_contact_informations_raw_mock.json")
+        payload["items"] = [payload["items"][0]]
+        m.get(url, text=json.dumps(payload))
+        rendered = queryMultiAdapter((self.page, self.request), name="full_view")()
+        self.assertNotIn("+3287123456", rendered)
+        self.assertNotIn("contact_informations_genral", rendered)
+
+    @requests_mock.Mocker()
+    def test_url_type_only_renders_icon_without_link(self, m):
+        # `type` and `url` are independently checkable for a urls row. With
+        # only `type` checked, the editor asked for the icon but not the
+        # link: the icon must still render, but NOT wrapped in an <a> (no
+        # href to link to).
+        section = api.content.create(
+            container=self.page,
+            type="imio.smartweb.SectionContact",
+            title="My contact",
+        )
+        section.visible_blocks = ["contact_informations"]
+        uid = "2dc381f0fb584381b8e4a19c84f53b35"
+        section.related_contacts = [uid]
+        url = "http://localhost:8080/Plone/@search?UID={}&fullobjects=1".format(uid)
+        payload = get_json("resources/json_contact_informations_raw_mock.json")
+        payload["items"] = [payload["items"][0]]
+        section.urls_display = [
+            {
+                "contact_uid": uid,
+                "url": "https://facebook.com/example",
+                "visible_columns": ["type"],
+            }
+        ]
+        m.get(url, text=json.dumps(payload))
+        rendered = queryMultiAdapter((self.page, self.request), name="full_view")()
+        self.assertIn("bi-facebook", rendered)
+        self.assertNotIn('href="https://facebook.com/example"', rendered)
+
+    @requests_mock.Mocker()
+    def test_url_only_hides_icon_and_type_leak(self, m):
+        # With only `url` checked, the link renders but neither the icon nor
+        # the translated type label may appear anywhere -- including as a
+        # `title=` attribute, which is the actual leak this guards against.
+        section = api.content.create(
+            container=self.page,
+            type="imio.smartweb.SectionContact",
+            title="My contact",
+        )
+        section.visible_blocks = ["contact_informations"]
+        uid = "2dc381f0fb584381b8e4a19c84f53b35"
+        section.related_contacts = [uid]
+        url = "http://localhost:8080/Plone/@search?UID={}&fullobjects=1".format(uid)
+        payload = get_json("resources/json_contact_informations_raw_mock.json")
+        payload["items"] = [payload["items"][0]]
+        section.urls_display = [
+            {
+                "contact_uid": uid,
+                "url": "https://facebook.com/example",
+                "visible_columns": ["url"],
+            }
+        ]
+        m.get(url, text=json.dumps(payload))
+        rendered = queryMultiAdapter((self.page, self.request), name="full_view")()
+        self.assertIn('href="https://facebook.com/example"', rendered)
+        self.assertNotIn("bi-facebook", rendered)
+        self.assertNotIn("Facebook", rendered)
+        # The title expression falls back to `nothing`, not to '', so TAL drops
+        # the attribute instead of emitting an empty `title=""`. Scoped to this
+        # anchor: unrelated Plone chrome does emit `title=""` elsewhere.
+        anchor = re.search(r"<a[^>]*https://facebook\.com/example[^>]*>", rendered)
+        self.assertIsNotNone(anchor)
+        self.assertNotIn("title=", anchor.group(0))
+
 
 class TestContactPropertiesMethods(ImioSmartwebTestCase):
     """Direct unit tests for ContactProperties methods in contact/utils.py"""
@@ -717,6 +950,9 @@ def setUp(self):
             "logo": None,
             "image": None,
             "urls": [],
+            "UID": "2dc381f0fb584381b8e4a19c84f53b35",
+            "phones": [],
+            "mails": [],
         }
 
     def _make_contact_properties(self, overrides=None):
@@ -895,3 +1131,479 @@ def test_getattr_returns_value_from_contact_dict(self):
     def test_getattr_returns_none_for_missing_key(self):
         cp = self._make_contact_properties()
         self.assertIsNone(cp.nonexistent_key)
+
+    # --- displayed_rows ---
+
+    _PHONES = [
+        {"label": "Secretariat", "type": "work", "number": "+3287123456"},
+        {"label": "Direction", "type": "cell", "number": "+32475010203"},
+    ]
+
+    def test_displayed_rows_without_preference_shows_every_column(self):
+        cp = self._make_contact_properties({"phones": self._PHONES})
+        rows = cp.displayed_rows("phones")
+        self.assertEqual(len(rows), 2)
+        self.assertEqual(rows[0]["columns"], {"label", "type", "number"})
+        self.assertEqual(rows[0]["data"]["number"], "+3287123456")
+
+    def test_displayed_rows_returns_the_remote_row_by_reference(self):
+        # `self.contact` is cached JSON shared across renders: `data` must be
+        # the SAME dict object as the remote row, never a copy, and must
+        # never gain the "columns" key. `_PHONES` entries are shared by
+        # reference into `self.contact["phones"]` (only the top-level contact
+        # dict is copied by `_make_contact_properties`), so `assertIs` here
+        # actually exercises identity, not just equality.
+        cp = self._make_contact_properties({"phones": self._PHONES})
+        rows = cp.displayed_rows("phones")
+        self.assertIs(rows[0]["data"], self._PHONES[0])
+        self.assertNotIn("columns", rows[0]["data"])
+
+    def test_displayed_rows_with_a_subset_returns_that_subset(self):
+        self.section.phones_display = [
+            {
+                "contact_uid": "2dc381f0fb584381b8e4a19c84f53b35",
+                "number": "+3287123456",
+                "visible_columns": ["number"],
+            }
+        ]
+        cp = self._make_contact_properties({"phones": self._PHONES})
+        rows = cp.displayed_rows("phones")
+        self.assertEqual(rows[0]["columns"], {"number"})
+        # The unlisted row keeps the default.
+        self.assertEqual(rows[1]["columns"], {"label", "type", "number"})
+
+    def test_displayed_rows_hides_a_row_with_an_empty_preference(self):
+        self.section.phones_display = [
+            {
+                "contact_uid": "2dc381f0fb584381b8e4a19c84f53b35",
+                "number": "+3287123456",
+                "visible_columns": [],
+            }
+        ]
+        cp = self._make_contact_properties({"phones": self._PHONES})
+        rows = cp.displayed_rows("phones")
+        self.assertEqual(len(rows), 1)
+        self.assertEqual(rows[0]["data"]["number"], "+32475010203")
+
+    def test_displayed_rows_distinguishes_none_from_an_empty_list(self):
+        # THE critical invariant. `None` means "no preference recorded" and
+        # must show every column; `[]` means "explicitly hidden". Normalising
+        # one into the other would either resurrect hidden rows or wipe the
+        # contact informations of every existing section.
+        base = {
+            "contact_uid": "2dc381f0fb584381b8e4a19c84f53b35",
+            "number": "+3287123456",
+        }
+        cp = self._make_contact_properties({"phones": self._PHONES[:1]})
+
+        self.section.phones_display = [{**base, "visible_columns": None}]
+        rows_for_none = cp.displayed_rows("phones")
+
+        self.section.phones_display = [{**base, "visible_columns": []}]
+        rows_for_empty = cp.displayed_rows("phones")
+
+        self.assertEqual(len(rows_for_none), 1)
+        self.assertEqual(rows_for_none[0]["columns"], {"label", "type", "number"})
+        self.assertEqual(rows_for_empty, [])
+
+    def test_displayed_rows_ignores_a_preference_from_another_contact(self):
+        self.section.phones_display = [
+            {
+                "contact_uid": "another-uid",
+                "number": "+3287123456",
+                "visible_columns": [],
+            }
+        ]
+        cp = self._make_contact_properties({"phones": self._PHONES})
+        self.assertEqual(len(cp.displayed_rows("phones")), 2)
+
+    def test_displayed_rows_drops_unknown_columns(self):
+        # A stale preference naming a column that no longer exists must not
+        # leak into the render.
+        self.section.phones_display = [
+            {
+                "contact_uid": "2dc381f0fb584381b8e4a19c84f53b35",
+                "number": "+3287123456",
+                "visible_columns": ["number", "gone"],
+            }
+        ]
+        cp = self._make_contact_properties({"phones": self._PHONES})
+        self.assertEqual(cp.displayed_rows("phones")[0]["columns"], {"number"})
+
+    def test_displayed_rows_skips_rows_without_a_key(self):
+        cp = self._make_contact_properties(
+            {
+                "urls": [
+                    {"type": None, "url": None},
+                    {"type": "facebook", "url": "https://example.be"},
+                ]
+            }
+        )
+        rows = cp.displayed_rows("urls")
+        self.assertEqual(len(rows), 1)
+        self.assertEqual(rows[0]["data"]["url"], "https://example.be")
+
+    def test_displayed_rows_tolerates_missing_remote_payload(self):
+        cp = self._make_contact_properties({"phones": None})
+        self.assertEqual(cp.displayed_rows("phones"), [])
+
+    def test_translated_type_delegates_to_the_label_table(self):
+        cp = self._make_contact_properties()
+        self.assertEqual(cp.translated_type("phones", "cell"), "Mobile")
+        self.assertEqual(cp.translated_type("phones", "pager"), "pager")
+
+
+class TestContactInformationsUtils(ImioSmartwebTestCase):
+    """Module-level helpers of contents/sections/contact/utils.py"""
+
+    layer = IMIO_SMARTWEB_CORE_INTEGRATION_TESTING
+
+    def setUp(self):
+        self.portal = self.layer["portal"]
+        self.request = self.layer["request"]
+        setRoles(self.portal, TEST_USER_ID, ["Manager"])
+        self.contacts = get_json(
+            "resources/json_contact_informations_raw_mock.json"
+        ).get("items")
+
+    def test_row_key_is_the_payload_value(self):
+        self.assertEqual(row_key("phones", {"number": " +3287123456 "}), "+3287123456")
+        self.assertEqual(
+            row_key("mails", {"mail_address": "info@example.be"}),
+            "info@example.be",
+        )
+        self.assertEqual(
+            row_key("urls", {"url": "https://example.be"}), "https://example.be"
+        )
+
+    def test_row_key_is_empty_when_the_payload_is_missing(self):
+        self.assertEqual(row_key("urls", {"type": "facebook", "url": None}), "")
+
+    def test_translated_type_label_uses_the_directory_msgids(self):
+        self.assertEqual(translated_type_label("phones", "cell"), "Mobile")
+        self.assertEqual(translated_type_label("mails", "work"), "Work email")
+        self.assertEqual(translated_type_label("urls", "facebook"), "Facebook")
+
+    def test_translated_type_label_falls_back_to_the_raw_token(self):
+        # The directory owns these vocabularies; an added type must degrade
+        # visibly rather than blow up.
+        self.assertEqual(translated_type_label("phones", "pager"), "pager")
+        self.assertEqual(translated_type_label("phones", None), "")
+
+    def test_build_display_rows_flattens_every_contact(self):
+        rows = build_display_rows("phones", self.contacts)
+        self.assertEqual(len(rows), 3)
+        self.assertEqual(
+            [row["contact_title"] for row in rows],
+            ["Administration communale", "Administration communale", "CPAS"],
+        )
+        self.assertEqual(
+            [row["number"] for row in rows],
+            ["+3287123456", "+32475010203", "+3287654321"],
+        )
+
+    def test_build_display_rows_translates_the_type_column(self):
+        rows = build_display_rows("phones", self.contacts)
+        self.assertEqual(rows[0]["type"], "Work phone")
+        self.assertEqual(rows[1]["type"], "Mobile")
+
+    def test_build_display_rows_defaults_to_every_column(self):
+        rows = build_display_rows("phones", self.contacts)
+        self.assertEqual(rows[0]["visible_columns"], ["label", "type", "number"])
+        rows = build_display_rows("urls", self.contacts)
+        self.assertEqual(rows[0]["visible_columns"], ["type", "url"])
+
+    def test_build_display_rows_carries_preferences_over(self):
+        uid = "2dc381f0fb584381b8e4a19c84f53b35"
+        preferences = {(uid, "+3287123456"): ["number"]}
+        rows = build_display_rows("phones", self.contacts, preferences)
+        self.assertEqual(rows[0]["visible_columns"], ["number"])
+        # Untouched rows keep the default.
+        self.assertEqual(rows[1]["visible_columns"], ["label", "type", "number"])
+
+    def test_build_display_rows_keeps_an_explicit_empty_preference(self):
+        # An empty list means "explicitly hidden" and must NOT be replaced by
+        # the all-columns default.
+        uid = "2dc381f0fb584381b8e4a19c84f53b35"
+        preferences = {(uid, "+3287123456"): []}
+        rows = build_display_rows("phones", self.contacts, preferences)
+        self.assertEqual(rows[0]["visible_columns"], [])
+
+    def test_build_display_rows_defaults_are_not_shared(self):
+        # Every row must own its list, otherwise editing one row's checkboxes
+        # would silently edit the others.
+        rows = build_display_rows("phones", self.contacts)
+        rows[0]["visible_columns"].append("boom")
+        self.assertEqual(rows[1]["visible_columns"], ["label", "type", "number"])
+
+    def test_build_display_rows_skips_rows_without_a_key(self):
+        contacts = [
+            {
+                "UID": "uid1",
+                "title": "C1",
+                "urls": [
+                    {"type": None, "url": None},
+                    {"type": "facebook", "url": "https://example.be"},
+                ],
+            }
+        ]
+        rows = build_display_rows("urls", contacts)
+        self.assertEqual(len(rows), 1)
+        self.assertEqual(rows[0]["url"], "https://example.be")
+
+    def test_build_display_rows_tolerates_missing_payload(self):
+        self.assertEqual(build_display_rows("phones", []), [])
+        self.assertEqual(
+            build_display_rows("phones", [{"UID": "uid1", "title": "C1"}]), []
+        )
+        self.assertEqual(
+            build_display_rows(
+                "phones", [{"UID": "uid1", "title": "C1", "phones": None}]
+            ),
+            [],
+        )
+
+    @requests_mock.Mocker()
+    def test_get_remote_contacts_preserves_the_requested_order(self, m):
+        uids = [
+            "af7bd1f547034b24a2e0da16c0ba0358",
+            "2dc381f0fb584381b8e4a19c84f53b35",
+        ]
+        url = "http://localhost:8080/Plone/@search?UID={}&fullobjects=1".format(
+            "&UID=".join(uids)
+        )
+        m.get(
+            url,
+            text=json.dumps(
+                get_json("resources/json_contact_informations_raw_mock.json")
+            ),
+        )
+        contacts = get_remote_contacts(uids)
+        self.assertEqual([contact["UID"] for contact in contacts], uids)
+
+    @requests_mock.Mocker()
+    def test_get_remote_contacts_returns_empty_on_failure(self, m):
+        uids = ["2dc381f0fb584381b8e4a19c84f53b35"]
+        url = "http://localhost:8080/Plone/@search?UID={}&fullobjects=1".format(uids[0])
+        m.get(url, status_code=404)
+        self.assertEqual(get_remote_contacts(uids), [])
+        self.assertEqual(get_remote_contacts([]), [])
+
+
+def _column_subsets(columns):
+    """Every subset of `columns`, from the empty set to the full set."""
+    return itertools.chain.from_iterable(
+        itertools.combinations(columns, size) for size in range(len(columns) + 1)
+    )
+
+
+class TestSectionContactColumnCombinations(ImioSmartwebTestCase):
+    """Exhaustive render coverage for `visible_columns` on a contact row.
+
+    Two column-combination bugs (the `urls` `type`/`url` coupling) already
+    slipped through review because nobody enumerated the combinations. This
+    class brute-forces every subset of every kind's columns and asserts
+    exactly what the rendered markup contains -- and, just as importantly,
+    what it must NOT contain, including inside attributes such as `title=`.
+
+    A parse error in `macros.pt` is swallowed by the section render (it
+    degrades instead of raising), so a test that only asserts absences would
+    pass against a dead template. Every non-empty-subset case therefore
+    carries at least one positive assertion that the row actually rendered,
+    and every empty-subset case asserts on markup that only
+    `contents/sections/contact/macros.pt` itself can emit -- an untouched
+    sibling row, or the list that would have held the hidden row -- so a dead
+    template cannot masquerade as a correctly hidden row. The section title is
+    NOT usable for that: it comes from `contents/sections/macros.pt`'s
+    `section_title` macro, a different template that would still render.
+    """
+
+    layer = IMIO_SMARTWEB_CORE_FUNCTIONAL_TESTING
+
+    uid = "2dc381f0fb584381b8e4a19c84f53b35"
+
+    def setUp(self):
+        self.request = self.layer["request"]
+        self.portal = self.layer["portal"]
+        setRoles(self.portal, TEST_USER_ID, ["Manager"])
+        payload = get_json("resources/json_contact_informations_raw_mock.json")
+        # Contact 1 only: the fixture also carries a second contact (CPAS)
+        # that this class's cases never reference.
+        payload["items"] = [payload["items"][0]]
+        self.payload = payload
+        self._page_counter = itertools.count()
+
+    def _new_section(self, display_field, display_row):
+        """A fresh Page + SectionContact, isolated from any other case.
+
+        The render cache is keyed off `IAnnotations` on the section object
+        itself (see `SECTION_ITEMS_HASH_KEY` in `contents/sections/views.py`),
+        so a brand-new section per case cannot be served a stale render from
+        a previous subset -- no `sleep`/`clear_cache` dance is needed here.
+        """
+        page = api.content.create(
+            container=self.portal,
+            type="imio.smartweb.Page",
+            id="page-{}".format(next(self._page_counter)),
+        )
+        section = api.content.create(
+            container=page,
+            type="imio.smartweb.SectionContact",
+            title="My contact",
+        )
+        section.visible_blocks = ["contact_informations"]
+        section.related_contacts = [self.uid]
+        setattr(section, display_field, [display_row])
+        return page
+
+    def _render(self, page, m):
+        url = "http://localhost:8080/Plone/@search?UID={}&fullobjects=1".format(
+            self.uid
+        )
+        m.get(url, text=json.dumps(self.payload))
+        return queryMultiAdapter((page, self.request), name="full_view")()
+
+    @requests_mock.Mocker()
+    def test_phones_column_combinations(self, m):
+        # {"label": "Secretariat", "type": "work", "number": "+3287123456"}
+        label = "Secretariat"
+        translated_type = "Work phone"
+        number = "+3287123456"
+        columns = ("label", "type", "number")
+
+        for subset in _column_subsets(columns):
+            with self.subTest(kind="phones", subset=subset):
+                page = self._new_section(
+                    "phones_display",
+                    {
+                        "contact_uid": self.uid,
+                        "number": number,
+                        "visible_columns": list(subset),
+                    },
+                )
+                rendered = self._render(page, m)
+
+                if not subset:
+                    # Every column hidden -> the row is not rendered at all.
+                    # The second phone of the fixture ("Direction") carries no
+                    # preference, so it still renders: proof that the phones
+                    # loop of contact/macros.pt really ran.
+                    self.assertIn("+32475010203", rendered)
+                    self.assertNotIn(label, rendered)
+                    self.assertNotIn(translated_type, rendered)
+                    self.assertNotIn(number, rendered)
+                    continue
+
+                if "label" in subset:
+                    self.assertIn(label, rendered)
+                else:
+                    self.assertNotIn(label, rendered)
+                if "type" in subset:
+                    self.assertIn(translated_type, rendered)
+                else:
+                    self.assertNotIn(translated_type, rendered)
+                if "number" in subset:
+                    self.assertIn(number, rendered)
+                else:
+                    self.assertNotIn(number, rendered)
+
+    @requests_mock.Mocker()
+    def test_mails_column_combinations(self, m):
+        # {"label": "Accueil", "type": "work", "mail_address": "info@example.be"}
+        label = "Accueil"
+        translated_type = "Work email"
+        mail_address = "info@example.be"
+        columns = ("label", "type", "mail_address")
+
+        for subset in _column_subsets(columns):
+            with self.subTest(kind="mails", subset=subset):
+                page = self._new_section(
+                    "mails_display",
+                    {
+                        "contact_uid": self.uid,
+                        "mail_address": mail_address,
+                        "visible_columns": list(subset),
+                    },
+                )
+                rendered = self._render(page, m)
+
+                if not subset:
+                    # The fixture holds a single mail row -- the hidden one --
+                    # so there is no untouched mail to assert on. The <ul> that
+                    # would have carried it is emitted by
+                    # contact/macros.pt alone (the untouched phone rows keep it
+                    # alive), which proves the template ran and simply left the
+                    # mail row out.
+                    self.assertIn("contact_informations_genral", rendered)
+                    self.assertNotIn(label, rendered)
+                    self.assertNotIn(translated_type, rendered)
+                    self.assertNotIn(mail_address, rendered)
+                    continue
+
+                if "label" in subset:
+                    self.assertIn(label, rendered)
+                else:
+                    self.assertNotIn(label, rendered)
+                if "type" in subset:
+                    self.assertIn(translated_type, rendered)
+                else:
+                    self.assertNotIn(translated_type, rendered)
+                if "mail_address" in subset:
+                    self.assertIn(mail_address, rendered)
+                else:
+                    self.assertNotIn(mail_address, rendered)
+
+    @requests_mock.Mocker()
+    def test_urls_column_combinations(self, m):
+        # {"type": "facebook", "url": "https://facebook.com/example"}
+        #
+        # Unlike phones/mails, `type` and `url` are NOT two independent
+        # pieces of text: `type` drives the icon, `url` drives the `<a
+        # href>`, and the translated label ("Facebook") only ever appears as
+        # the link's `title=` attribute, which is only built when BOTH
+        # columns are visible. So: icon <=> 'type' in subset; href/link text
+        # <=> 'url' in subset; translated label <=> both.
+        target_url = "https://facebook.com/example"
+        href = 'href="{}"'.format(target_url)
+        icon = "bi-facebook"
+        translated_type = "Facebook"
+        columns = ("type", "url")
+
+        for subset in _column_subsets(columns):
+            with self.subTest(kind="urls", subset=subset):
+                page = self._new_section(
+                    "urls_display",
+                    {
+                        "contact_uid": self.uid,
+                        "url": target_url,
+                        "visible_columns": list(subset),
+                    },
+                )
+                rendered = self._render(page, m)
+
+                if not subset:
+                    # The `website` row of the fixture carries no preference,
+                    # so it still renders: proof that the urls loop of
+                    # contact/macros.pt really ran.
+                    self.assertIn('href="https://example.be"', rendered)
+                    self.assertNotIn(href, rendered)
+                    self.assertNotIn(target_url, rendered)
+                    self.assertNotIn(icon, rendered)
+                    self.assertNotIn(translated_type, rendered)
+                    continue
+
+                if "url" in subset:
+                    self.assertIn(href, rendered)
+                else:
+                    self.assertNotIn(href, rendered)
+                    self.assertNotIn(target_url, rendered)
+
+                if "type" in subset:
+                    self.assertIn(icon, rendered)
+                else:
+                    self.assertNotIn(icon, rendered)
+
+                if set(subset) == {"type", "url"}:
+                    self.assertIn(translated_type, rendered)
+                else:
+                    self.assertNotIn(translated_type, rendered)
diff --git a/src/imio/smartweb/core/tests/test_section_contact_forms.py b/src/imio/smartweb/core/tests/test_section_contact_forms.py
new file mode 100644
index 00000000..8423e2c6
--- /dev/null
+++ b/src/imio/smartweb/core/tests/test_section_contact_forms.py
@@ -0,0 +1,426 @@
+# -*- coding: utf-8 -*-
+
+from imio.smartweb.core.contents.sections.contact.forms import ContactCustomAddForm
+from imio.smartweb.core.contents.sections.contact.forms import ContactCustomEditForm
+from imio.smartweb.core.testing import IMIO_SMARTWEB_CORE_FUNCTIONAL_TESTING
+from imio.smartweb.core.testing import IMIO_SMARTWEB_CORE_INTEGRATION_TESTING
+from imio.smartweb.core.testing import ImioSmartwebTestCase
+from imio.smartweb.core.tests.utils import get_json
+from plone import api
+from plone.app.testing import setRoles
+from plone.app.testing import TEST_USER_ID
+from plone.app.testing import TEST_USER_NAME
+from plone.app.testing import TEST_USER_PASSWORD
+from plone.testing.zope import Browser
+from Products.statusmessages.interfaces import IStatusMessage
+from zope.component import queryUtility
+from zope.ramcache.interfaces.ram import IRAMCache
+
+import json
+import requests_mock
+import transaction
+
+CONTACT_UID = "2dc381f0fb584381b8e4a19c84f53b35"
+OTHER_CONTACT_UID = "af7bd1f547034b24a2e0da16c0ba0358"
+SEARCH_URL = "http://localhost:8080/Plone/@search?UID={}&fullobjects=1".format(
+    CONTACT_UID
+)
+BOTH_SEARCH_URL = (
+    "http://localhost:8080/Plone/@search?UID={}&UID={}&fullobjects=1".format(
+        CONTACT_UID, OTHER_CONTACT_UID
+    )
+)
+# RemoteContactsVocabulary feeds the related_contacts field. The edit form
+# validates the submitted UID against it on save, so it has to know our UID.
+VOCABULARY_URL = (
+    "http://localhost:8080/Plone/@search"
+    "?portal_type=imio.directory.Contact"
+    "&selected_entities=396907b3b1b04a97896b12cc792c77f8"
+    "&sort_on=breadcrumb&b_size=1000000"
+    "&metadata_fields=UID&metadata_fields=breadcrumb"
+)
+
+
+class TestContactCustomEditForm(ImioSmartwebTestCase):
+    layer = IMIO_SMARTWEB_CORE_INTEGRATION_TESTING
+
+    def setUp(self):
+        self.portal = self.layer["portal"]
+        self.request = self.layer["request"]
+        setRoles(self.portal, TEST_USER_ID, ["Manager"])
+        self.page = api.content.create(
+            container=self.portal, type="imio.smartweb.Page", id="page"
+        )
+        self.section = api.content.create(
+            container=self.page,
+            type="imio.smartweb.SectionContact",
+            title="My contact",
+        )
+        payload = get_json("resources/json_contact_informations_raw_mock.json")
+        self.both_payload = json.loads(json.dumps(payload))
+        payload["items"] = [payload["items"][0]]
+        self.payload = payload
+
+    def _make_form(self, form_data):
+        self.request.form.clear()
+        self.request.form.update(form_data)
+        return ContactCustomEditForm(self.section, self.request)
+
+    def _messages(self):
+        """(type, text) of the status messages the editor will be shown."""
+        return [
+            (message.type, message.message)
+            for message in IStatusMessage(self.request).show()
+        ]
+
+    def test_keeps_the_base_buttons(self):
+        # A bare @buttonAndHandler in the class body would shadow the base
+        # form's Buttons manager and drop Save / Cancel.
+        names = [button.__name__ for button in ContactCustomEditForm.buttons.values()]
+        self.assertIn("save", names)
+        self.assertIn("cancel", names)
+        self.assertIn("load_contact_informations", names)
+
+    def test_keeps_the_base_handlers(self):
+        # @buttonAndHandler ALSO setdefaults `handlers` in the class body. A
+        # missing `handlers = <Base>.handlers.copy()` leaves the Save button
+        # rendered but handler-less: pressing it silently saves nothing.
+        for form_class in (ContactCustomEditForm, ContactCustomAddForm):
+            handlers = form_class.handlers
+            handled = [button.__name__ for button, _handler in handlers._handlers]
+            self.assertIn("save", handled, form_class.__name__)
+            self.assertIn("cancel", handled, form_class.__name__)
+            self.assertIn("load_contact_informations", handled, form_class.__name__)
+            for name in ("save", "cancel"):
+                self.assertIsNotNone(
+                    handlers.getHandler(form_class.buttons[name]),
+                    "{} lost its {} handler".format(form_class.__name__, name),
+                )
+
+    def test_the_base_handlers_are_not_polluted(self):
+        # The copy must be a copy: addHandler mutates in place, so sharing the
+        # base manager would add our button's handler to every dexterity form.
+        from plone.dexterity.browser.edit import DefaultEditForm
+
+        handled = [button.__name__ for button, _h in DefaultEditForm.handlers._handlers]
+        self.assertEqual(sorted(handled), ["cancel", "save"])
+
+    @requests_mock.Mocker()
+    def test_reload_writes_one_request_row_per_remote_row(self, m):
+        m.get(SEARCH_URL, text=json.dumps(self.payload))
+        form = self._make_form(
+            {
+                "form.buttons.load_contact_informations": "Load",
+                "form.widgets.related_contacts": [CONTACT_UID],
+            }
+        )
+        form._reload_display_grids()
+        request_form = self.request.form
+        self.assertEqual(request_form["form.widgets.phones_display.count"], "2")
+        self.assertEqual(
+            request_form["form.widgets.phones_display.0.widgets.number"],
+            "+3287123456",
+        )
+        self.assertEqual(
+            request_form["form.widgets.phones_display.0.widgets.contact_uid"],
+            CONTACT_UID,
+        )
+        self.assertEqual(
+            request_form["form.widgets.phones_display.0.widgets.contact_title"],
+            "Administration communale",
+        )
+        self.assertEqual(
+            request_form["form.widgets.phones_display.0.widgets.type"], "Work phone"
+        )
+        self.assertEqual(
+            request_form["form.widgets.phones_display.0.widgets.visible_columns"],
+            ["label", "type", "number"],
+        )
+        self.assertEqual(
+            request_form[
+                "form.widgets.phones_display.0.widgets.visible_columns-empty-marker"
+            ],
+            "1",
+        )
+        self.assertEqual(request_form["form.widgets.mails_display.count"], "1")
+        self.assertEqual(request_form["form.widgets.urls_display.count"], "2")
+        # A successful load is confirmed to the editor.
+        messages = self._messages()
+        self.assertEqual([type_ for type_, _text in messages], ["info"])
+        self.assertIn("has been loaded", messages[0][1])
+
+    @requests_mock.Mocker()
+    def test_reload_preserves_the_checkboxes_already_submitted(self, m):
+        m.get(SEARCH_URL, text=json.dumps(self.payload))
+        form = self._make_form(
+            {
+                "form.buttons.load_contact_informations": "Load",
+                "form.widgets.related_contacts": [CONTACT_UID],
+                "form.widgets.phones_display.count": "1",
+                "form.widgets.phones_display.0.widgets.contact_uid": CONTACT_UID,
+                "form.widgets.phones_display.0.widgets.number": "+3287123456",
+                "form.widgets.phones_display.0.widgets.visible_columns": ["number"],
+                "form.widgets.phones_display.0.widgets.visible_columns-empty-marker": "1",  # noqa: E501
+            }
+        )
+        form._reload_display_grids()
+        self.assertEqual(
+            self.request.form["form.widgets.phones_display.0.widgets.visible_columns"],
+            ["number"],
+        )
+        # The row that was not in the request keeps the all-columns default.
+        self.assertEqual(
+            self.request.form["form.widgets.phones_display.1.widgets.visible_columns"],
+            ["label", "type", "number"],
+        )
+
+    @requests_mock.Mocker()
+    def test_reload_reads_an_all_unchecked_row_as_an_empty_list(self, m):
+        # An unchecked checkbox group submits nothing but its empty-marker.
+        # That must be read as "explicitly hidden" ([]), not as "no preference".
+        m.get(SEARCH_URL, text=json.dumps(self.payload))
+        form = self._make_form(
+            {
+                "form.buttons.load_contact_informations": "Load",
+                "form.widgets.related_contacts": [CONTACT_UID],
+                "form.widgets.phones_display.count": "1",
+                "form.widgets.phones_display.0.widgets.contact_uid": CONTACT_UID,
+                "form.widgets.phones_display.0.widgets.number": "+3287123456",
+                "form.widgets.phones_display.0.widgets.visible_columns-empty-marker": "1",  # noqa: E501
+            }
+        )
+        form._reload_display_grids()
+        self.assertEqual(
+            self.request.form["form.widgets.phones_display.0.widgets.visible_columns"],
+            [],
+        )
+
+    @requests_mock.Mocker()
+    def test_reload_drops_stale_rows(self, m):
+        m.get(SEARCH_URL, text=json.dumps(self.payload))
+        form = self._make_form(
+            {
+                "form.buttons.load_contact_informations": "Load",
+                "form.widgets.related_contacts": [CONTACT_UID],
+                "form.widgets.phones_display.count": "9",
+                "form.widgets.phones_display.7.widgets.contact_uid": "gone",
+                "form.widgets.phones_display.7.widgets.number": "+3200000000",
+            }
+        )
+        form._reload_display_grids()
+        self.assertNotIn(
+            "form.widgets.phones_display.7.widgets.number", self.request.form
+        )
+        self.assertEqual(self.request.form["form.widgets.phones_display.count"], "2")
+
+    def test_reload_without_related_contacts_empties_the_grids(self):
+        form = self._make_form({"form.buttons.load_contact_informations": "Load"})
+        form._reload_display_grids()
+        for field_name in ("phones_display", "mails_display", "urls_display"):
+            self.assertEqual(
+                self.request.form["form.widgets.{}.count".format(field_name)], "0"
+            )
+        # No contact really means no row, but the editor must be told why the
+        # grids came back empty.
+        messages = self._messages()
+        self.assertEqual([type_ for type_, _text in messages], ["info"])
+        self.assertIn("select a contact", messages[0][1])
+
+    @requests_mock.Mocker()
+    def test_reload_keeps_the_grids_when_the_directory_is_unreachable(self, m):
+        # get_remote_contacts cannot distinguish a 404 / timeout / unreachable
+        # host from "no results": utils.get_json swallows everything and
+        # returns None. Emptying the grids here would destroy every recorded
+        # visible_columns preference as soon as the editor pressed Save.
+        m.get(SEARCH_URL, status_code=404)
+        form = self._make_form(
+            {
+                "form.buttons.load_contact_informations": "Load",
+                "form.widgets.related_contacts": [CONTACT_UID],
+                "form.widgets.phones_display.count": "1",
+                "form.widgets.phones_display.0.widgets.contact_uid": CONTACT_UID,
+                "form.widgets.phones_display.0.widgets.number": "+3287123456",
+                "form.widgets.phones_display.0.widgets.visible_columns": ["number"],
+                "form.widgets.phones_display.0.widgets.visible_columns-empty-marker": "1",  # noqa: E501
+            }
+        )
+        form._reload_display_grids()
+        request_form = self.request.form
+        self.assertEqual(request_form["form.widgets.phones_display.count"], "1")
+        self.assertEqual(
+            request_form["form.widgets.phones_display.0.widgets.visible_columns"],
+            ["number"],
+        )
+        self.assertEqual(
+            request_form["form.widgets.phones_display.0.widgets.number"], "+3287123456"
+        )
+        messages = self._messages()
+        self.assertEqual([type_ for type_, _text in messages], ["error"])
+        self.assertIn("could not be reached", messages[0][1])
+
+    @requests_mock.Mocker()
+    def test_reload_accepts_a_single_uid_as_a_string(self, m):
+        # A single-valued select submits a bare string, not a list.
+        m.get(SEARCH_URL, text=json.dumps(self.payload))
+        form = self._make_form(
+            {
+                "form.buttons.load_contact_informations": "Load",
+                "form.widgets.related_contacts": CONTACT_UID,
+            }
+        )
+        form._reload_display_grids()
+        self.assertEqual(self.request.form["form.widgets.phones_display.count"], "2")
+
+    @requests_mock.Mocker()
+    def test_reload_splits_the_ajaxselect_joined_uids(self, m):
+        # related_contacts is an AjaxSelectWidget: several selected contacts
+        # arrive as ONE ";"-joined string. Taking it as a single UID would
+        # query a bogus "uid1;uid2" and load nothing.
+        m.get(BOTH_SEARCH_URL, text=json.dumps(self.both_payload))
+        form = self._make_form(
+            {
+                "form.buttons.load_contact_informations": "Load",
+                "form.widgets.related_contacts": "{};{}".format(
+                    CONTACT_UID, OTHER_CONTACT_UID
+                ),
+            }
+        )
+        form._reload_display_grids()
+        # 2 phones for the first contact, 1 for the second.
+        self.assertEqual(self.request.form["form.widgets.phones_display.count"], "3")
+        self.assertEqual(
+            self.request.form["form.widgets.phones_display.2.widgets.contact_uid"],
+            OTHER_CONTACT_UID,
+        )
+        self.assertEqual(
+            self.request.form["form.widgets.phones_display.2.widgets.contact_title"],
+            "CPAS",
+        )
+
+
+class TestContactInformationsGridRoundTrip(ImioSmartwebTestCase):
+    """Load then Save the grids through the real edit form in a browser."""
+
+    layer = IMIO_SMARTWEB_CORE_FUNCTIONAL_TESTING
+
+    def setUp(self):
+        self.portal = self.layer["portal"]
+        self.request = self.layer["request"]
+        setRoles(self.portal, TEST_USER_ID, ["Manager"])
+        self.page = api.content.create(
+            container=self.portal, type="imio.smartweb.Page", id="page"
+        )
+        self.section = api.content.create(
+            container=self.page,
+            type="imio.smartweb.SectionContact",
+            id="my-contact",
+            title="My contact",
+        )
+        self.section.related_contacts = [CONTACT_UID]
+        payload = get_json("resources/json_contact_informations_raw_mock.json")
+        payload["items"] = [payload["items"][0]]
+        self.payload = payload
+        transaction.commit()
+
+    def _browser(self):
+        browser = Browser(self.layer["app"])
+        browser.addHeader(
+            "Authorization",
+            "Basic %s:%s"
+            % (
+                TEST_USER_NAME,
+                TEST_USER_PASSWORD,
+            ),
+        )
+        return browser
+
+    def _mock_directory(self, m):
+        m.get(SEARCH_URL, text=json.dumps(self.payload))
+        m.get(
+            VOCABULARY_URL,
+            text=json.dumps(
+                {
+                    "items": [
+                        {
+                            "UID": CONTACT_UID,
+                            "breadcrumb": "Administration communale",
+                        }
+                    ]
+                }
+            ),
+        )
+        # RemoteContactsVocabulary is @ram.cache'd on a time bucket only, so a
+        # previous test may have cached an empty vocabulary for this minute.
+        cache = queryUtility(IRAMCache)
+        if cache is not None:
+            cache.invalidateAll()
+
+    def test_load_button_then_save_persists_the_grids(self):
+        with requests_mock.Mocker() as m:
+            self._mock_directory(m)
+            browser = self._browser()
+            browser.open("{}/edit".format(self.section.absolute_url()))
+            self.assertIn("form.widgets.phones_display", browser.contents)
+            browser.getControl(name="form.buttons.load_contact_informations").click()
+            content = browser.contents
+            # The grid is populated from the live directory payload...
+            self.assertIn("+3287123456", content)
+            self.assertIn("Administration communale", content)
+            self.assertIn("Secretariat", content)
+            # ...and the data columns render as frozen labels, i.e. a span
+            # plus a hidden input, so they are still submitted on save.
+            self.assertIn('<span class="dgf-frozen-label">+3287123456</span>', content)
+            self.assertIn(
+                'name="form.widgets.phones_display.0.widgets.number"', content
+            )
+            self.assertEqual(
+                browser.getControl(name="form.widgets.phones_display.count").value,
+                "2",
+            )
+            # Hide the label of the first phone, then save.
+            browser.getControl(
+                name="form.widgets.phones_display.0.widgets.visible_columns:list"
+            ).value = ["type", "number"]
+            browser.getControl(name="form.buttons.save").click()
+            saved_content = browser.contents
+
+        self.assertNotIn("Required input is missing", saved_content)
+        self.assertNotIn("system could not process the given value", saved_content)
+        self.assertNotIn(
+            "There were some errors", saved_content, "the save form errored out"
+        )
+
+        transaction.begin()
+        section = self.portal["page"]["my-contact"]
+        phones = section.phones_display
+        self.assertEqual(len(phones), 2, "phones_display did not persist")
+        self.assertEqual(phones[0]["contact_uid"], CONTACT_UID)
+        self.assertEqual(phones[0]["number"], "+3287123456")
+        self.assertEqual(phones[0]["contact_title"], "Administration communale")
+        self.assertEqual(phones[0]["visible_columns"], ["type", "number"])
+        self.assertEqual(phones[1]["number"], "+32475010203")
+        self.assertEqual(phones[1]["visible_columns"], ["label", "type", "number"])
+        self.assertEqual(len(section.mails_display), 1)
+        self.assertEqual(section.mails_display[0]["mail_address"], "info@example.be")
+        self.assertEqual(len(section.urls_display), 2)
+        self.assertEqual(section.urls_display[0]["url"], "https://example.be")
+
+    def test_add_form_keeps_its_buttons_and_loads_the_grids(self):
+        with requests_mock.Mocker() as m:
+            self._mock_directory(m)
+            browser = self._browser()
+            browser.open(
+                "{}/++add++imio.smartweb.SectionContact".format(
+                    self.page.absolute_url()
+                )
+            )
+            # Save and Cancel must survive the extra button.
+            browser.getControl(name="form.buttons.save")
+            browser.getControl(name="form.buttons.cancel")
+            browser.getControl(name="form.widgets.related_contacts").value = CONTACT_UID
+            browser.getControl(name="form.buttons.load_contact_informations").click()
+            content = browser.contents
+        self.assertIn("+3287123456", content)
+        self.assertIn('<span class="dgf-frozen-label">+3287123456</span>', content)
+        self.assertIn("info@example.be", content)
+        self.assertIn("https://example.be", content)
diff --git a/src/imio/smartweb/core/tests/test_vocabularies.py b/src/imio/smartweb/core/tests/test_vocabularies.py
index 06fd2654..e7b05962 100644
--- a/src/imio/smartweb/core/tests/test_vocabularies.py
+++ b/src/imio/smartweb/core/tests/test_vocabularies.py
@@ -98,6 +98,31 @@ def test_subsite_display_mode(self):
     def test_contact_blocks(self):
         self.assertVocabularyLen("imio.smartweb.vocabulary.ContactBlocks", 10)
 
+    def test_contact_display_columns_vocabularies(self):
+        self.assertVocabularyLen("imio.smartweb.vocabulary.PhoneDisplayColumns", 3)
+        self.assertVocabularyLen("imio.smartweb.vocabulary.MailDisplayColumns", 3)
+        self.assertVocabularyLen("imio.smartweb.vocabulary.UrlDisplayColumns", 2)
+
+    def test_contact_display_columns_tokens(self):
+        # The tokens must match the remote row schema keys exactly: they are
+        # looked up against the directory JSON payload at render time.
+        factory = getUtility(
+            IVocabularyFactory, "imio.smartweb.vocabulary.PhoneDisplayColumns"
+        )
+        self.assertEqual(
+            [term.token for term in factory()], ["label", "type", "number"]
+        )
+        factory = getUtility(
+            IVocabularyFactory, "imio.smartweb.vocabulary.MailDisplayColumns"
+        )
+        self.assertEqual(
+            [term.token for term in factory()], ["label", "type", "mail_address"]
+        )
+        factory = getUtility(
+            IVocabularyFactory, "imio.smartweb.vocabulary.UrlDisplayColumns"
+        )
+        self.assertEqual([term.token for term in factory()], ["type", "url"])
+
     @requests_mock.Mocker()
     def test_empty_remote_directory_entities(self, m):
         m.get(