• 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

Introduction to templates

We’ve seen quickly in the first part of this document that templates are guidelines for editors when creating pages, and used by Jahia to generate final HTML pages by gathering nodes and placing them it the right place.

As a developer, it is important for you to understand what exactly a template is and how the mechanism works. We’ll use an analogy to explain that.

Imagine that a template is a wooden tray like the ones small kids play with. The wooden tray has holes of various shapes, and the kid has corresponding wooden pieces. The aim of the game is to fill the holes with the wood pieces.

Templates are similar to those trays. As a template developer you start with a simple plain plank, and you dig holes in that tray. Each hole has a well-defined position and a name. Holes are called areas in the Jahia lingo.

On the other side, the wood pieces are the content objects the editors (the child) can insert in those holes. Each content object has a different shape so we can compare shapes to content definitions. Jahia provides by default a large number of pieces of different shapes, but you, as a developer, can reshape some of them (customize Jahia), remove some of them, or add news ones the kids will be allowed to play with.

Where Jahia differs from a standard wooden tray (and from most CMS) is that the areas can be filled nicely by any piece of wood, while a cubic hole will normally never receive a star or a circle. That’s magic! By default an area is just a position and therefore it’s very easy for kids to insert their wooden cubes or triangles.

It happens that kids must be driven a bit, that’s why you can also define that an area can receive only cubes, or only cubes and stars, or cubes, stars and rectangles, even specify a number of items that a particular hole can accept. Defining those restrictions is typical templating work that responds to ergonomic or functional constraints.

Finally, thanks to views, the same wooden tray with the same wood pieces can produce very different results at the end. Defining the default view that will be applied when content is added in particular positions of the pages is also part of the template development work. It’s up to you to decide if the kids can turn their cubes (change the view) or not.