How the menu system works

Basic concepts

Soft Roots

A soft root is a page that acts as the root for a menu navigation tree.

Typically, this will be a page that is the root of a significant new section on your site.

When the soft root feature is enabled, the navigation menu for any page will start at the nearest soft root, rather than at the real root of the site’s page hierarchy.

This feature is useful when your site has deep page hierarchies (and therefore multiple levels in its navigation trees). In such a case, you usually don’t want to present site visitors with deep menus of nested items.

For example, you’re on the page “Introduction to Bleeding”, so the menu might look like this:

  1. School of Medicine
  2. Medical Education
  3. Departments
  4. Department of Lorem Ipsum
  5. Department of Donec Imperdiet
  6. Department of Cras Eros
  7. Department of Mediaeval Surgery
  8. Theory
  9. Cures
  10. Bleeding
  11. * Introduction to Bleeding <current page>
  12. Bleeding - the scientific evidence
  13. Cleaning up the mess
  14. Cupping
  15. Leaches
  16. Maggots
  17. Techniques
  18. Instruments
  19. Department of Curabitur a Purus
  20. Department of Sed Accumsan
  21. Department of Etiam
  22. Research
  23. Administration
  24. Contact us
  25. Impressum

which is frankly overwhelming.

By making “Department of Mediaeval Surgery” a soft root, the menu becomes much more manageable:

  1. Department of Mediaeval Surgery
  2. Theory
  3. Cures
  4. Bleeding
  5. * Introduction to Bleeding <current page>
  6. Bleeding - the scientific evidence
  7. Cleaning up the mess
  8. Cupping
  9. Leaches
  10. Maggots
  11. Techniques
  12. Instruments

Registration

The menu system isn’t monolithic. Rather, it is composed of numerous active parts, many of which can operate independently of each other.

What they operate on is a list of menu nodes, that gets passed around the menu system, until it emerges at the other end.

The main active parts of the menu system are menu generators and modifiers.

Some of these parts are supplied with the menus application. Some come from other applications (from the cms application in django CMS, for example, or some other application entirely).

All these active parts need to be registered within the menu system.

Then, when the time comes to build a menu, the system will ask all the registered menu generators and modifiers to get to work on it.

Generators and Modifiers

Menu generators and modifiers are classes.

Generators

To add nodes to a menu a generator is required.

There is one in cms for example, which examines the Pages in the database and adds them as nodes.

These classes are sub-classes of menus.base.Menu. The one in cms is cms.menu.CMSMenu.

In order to use a generator, its get_nodes() method must be called.

Modifiers

A modifier examines the nodes that have been assembled, and modifies them according to its requirements (adding or removing them, or manipulating their attributes, as it sees fit).

An important one in cms (cms.menu.SoftRootCutter) removes the nodes that are no longer required when a soft root is encountered.

These classes are sub-classes of menus.base.Modifier. Examples are cms.menu.NavExtender and cms.menu.SoftRootCutter.

In order to use a modifier, its modify() method must be called.

Note that each Modifier’s modify() method can be called twice, before and after the menu has been trimmed.

For example when using the {% show_menu %} template tag, it’s called:

This corresponds to the state of the nodes list before and after menus.templatetags.menu_tags.cut_levels(), which removes nodes from the menu according to the arguments provided by the template tag.

This is because some modification might be required on all nodes, and some might only be required on the subset of nodes left after cutting.

Nodes

Nodes are assembled in a tree. Each node is an instance of the menus.base.NavigationNode class.

A NavigationNode has attributes such as URL, title, parent and children - as one would expect in a navigation tree.

It also has an attr attribute, a dictionary that’s provided for you to add arbitrary attributes to, rather than placing them directly on the node itself, where they might clash with something.

Warning

You can’t assume that a menus.base.NavigationNode represents a django CMS Page. Firstly, some nodes may represent objects from other applications. Secondly, you can’t expect to be able to access Page objects via NavigationNodes. To check if node represents a CMS Page, check for is_page in menus.base.NavigationNode.attr and that it is True.

Menu system logic

Let’s look at an example using the {% show_menu %} template tag. It will be different for other template tags, and your applications might have their own menu classes. But this should help explain what’s going on and what the menu system is doing.

One thing to understand is that the system passes around a list of nodes, doing various things to it.

Many of the methods below pass this list of nodes to the ones it calls, and return them to the ones that they were in turn called by.

Don’t forget that show_menu recurses - so it will do all of the below for each level in the menu.

  1. - were now back in [`menus.templatetags.menu_tags.ShowMenu.get_context()`]($0190d39cacf10fe7.md#menus.templatetags.menu_tags.ShowMenu.get_context "menus.templatetags.menu_tags.ShowMenu.get_context") again
  2. - if we have been provided a root\_id, get rid of any nodes other than its descendants
  3. - [`menus.templatetags.menu_tags.cut_levels()`]($0190d39cacf10fe7.md#menus.templatetags.menu_tags.cut_levels "menus.templatetags.menu_tags.cut_levels") removes nodes from the menu according to the arguments provided by the template tag
  4. - [`menus.menu_pool.MenuPool.apply_modifiers()`]($0190d39cacf10fe7.md#menus.menu_pool.MenuPool.apply_modifiers "menus.menu_pool.MenuPool.apply_modifiers") with `post_cut = True` loops over all the Modifiers again
  5. - [`cms.menu.NavExtender`]($0190d39cacf10fe7.md#cms.menu.NavExtender "cms.menu.NavExtender")
  6. - [`cms.menu.SoftRootCutter`]($0190d39cacf10fe7.md#cms.menu.SoftRootCutter "cms.menu.SoftRootCutter")
  7. - [`menus.modifiers.Marker`]($0190d39cacf10fe7.md#menus.modifiers.Marker "menus.modifiers.Marker")
  8. - [`menus.modifiers.AuthVisibility`]($0190d39cacf10fe7.md#menus.modifiers.AuthVisibility "menus.modifiers.AuthVisibility")
  9. - [`menus.modifiers.Level`]($0190d39cacf10fe7.md#menus.modifiers.Level "menus.modifiers.Level"):
  10. - [`menus.modifiers.Level.mark_levels()`]($0190d39cacf10fe7.md#menus.modifiers.Level.mark_levels "menus.modifiers.Level.mark_levels")
  11. - return the nodes to the context in the variable `children`