• Templating and Integration Guide
  • Part 1: Concepts
    • The "Everything is Content" Paradigm
      • Content items are objects with properties that correspond to a type
      • Nodes are stored in workspaces, organized in trees
    • The rendering flow
      • To render a node, you need a view
      • To render a page, you need a template
    • Modules are packages used to deploy “code” into Jahia
    • The Jahia actors
      • Content flow
  • Part 2: Modules
    • What is a module?
    • Module type
    • Module creation
    • Anatomy of a module
    • Adding classes and Jars in modules
    • Spring files
  • Part 3: Templates and Studio
    • Introduction to templates
    • Studio
      • Studio overview
    • Creating a template-set
      • Using the Maven archetype
      • Using Eclipse
      • Using Jahia Studio
      • Update the Maven project when templates are modified in the Studio
    • Building templates
      • There are 3 different kind of templates
      • Main Resource and template resolution
      • Areas in detail
      • Content templates in details
      • Bound Components
    • CSS style sheets and design
      • Preparing your stylesheet
      • Including stylesheets in templates
      • Managing different stylesheets depending on the context
      • Print friendly CSS
      • CSS frameworks and handmade XHTML
    • Themes
      • How it works
    • Skins
      • Creating skins
      • Skin rendering
  • Part 4: Content Definitions and Views
    • Definitons
      • NodeType
      • Namespaces
      • Supertypes
      • Options
      • Node Type properties
      • Input masks
      • Default values
      • Initializers
      • Validators
      • Abstract types
      • In practice: create the node type definition for dogs
    • Views
      • NodeType folders
      • Output formats
      • Default view
      • Other views
      • Modules versus Components
      • Module packaging and deployement
    • Managing URLs in scripts
    • Managing lists
      • Summary for a simple list
      • Using list views
    • Managing and customizing navigation menus
      • Menu Rendering
      • Customization
  • Part 5: Advanced Techniques
    • Search and queries
      • Full text queries using search tag libraries
      • Queries
      • In practice: creating a custom search component
    • Forms
      • Principles
      • Form data parameters
      • In practice: Transform a custom HTML form into a Jahia valid form step by step
    • Macros
      • Macro implementation languages
      • Typical usage
    • Caches
  • Part 6: Setting up an integration environment
    • Software Requirements
    • Maven configuration for Eclipse IDE
    • Maven External Configuration
    • Creating a template set
  • Part 7: Step by step integration
    • Cutting of the mockup
    • Integration of the Base
    • CSS / Javascript integration
    • Creating the content zones
  • Further reading and resources

To render a page, you need a template

We’ve seen that each node at some point must be processed through a view to add some formatting instructions, but a node alone is nearly never displayed as-is to readers. Actually, whatever the support they use (web browser, mobile application, etc.), readers receive web pages that includes headers, footers, navigation bars, breadcrumb, etc. instead of only one single node.

A page is therefore an assembly of nodes, driven by a template. The template is nothing more than a guide which

• Specifies the position of various elements in the page
• Load the necessary resources (CSS, Javascript) to apply layout/design instructions
• Renders some items that must be shared between pages

During the rendering process, content (content nodes processed with a view) and templates are blended together to produce the final pages.

In the example presented above, we are requesting a content object from the Java Content Repository (a.k.a. JCR) that is located on the home page and that is called “bellini”. Jahia will therefore first use the URL to find the corresponding content object, and then starts looking for different objects that will help render the final page.

The template defines the layout of the final page: the positions of all content items and loads the static resources like Javascript files and CSS stylesheets.

It is now time to look at how those definitions, views, templates and other advanced features may be deployed into Jahia. This is where modules come into play.