• 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

For template developers, Jahia 6.5 (and therefore 6.6) was not just a new version of an already proven platform or a minor update free of consequences. Instead, from a developer’s point of view, Jahia 6.5 presented all the characteristics of a restart from scratch.  After years of relatively incremental improvements on templates development mechanisms, the Jahia team went back to the drawing board to offer users a rapid, robust, scalable, understandable and hopefully fun development environment.

While designing Jahia 6.5, our goal was to provide as much flexibility as possible to developers, and to be able to respond positively to more and more complex demands from customers. To achieve this goal, we have rewritten the whole system of page rendering and, of ourse, how the templates should be developed themselves. We have concentrated our efforts on the concepts of modularity, ability to work in teams, developments reuse and the possibility for integrators to insert their own code at all levels of the platform, which was previously more difficult to do in previous versions of Jahia.

Accordingly, Jahia 6.6 offers many integration points for developers who wish to build advanced applications, from the lowest layers to the upper layers. Those upper layers consist of templates, script files, CSS integration and content object definitions.

Jahia 6.6 is a version upgrade that introduced no changes in terms of templating and all underlying mechanisms remains mainly stable. Improvements have been introduced in modules dependencies and deployment through the Studio.

This guide covers only the tip of the iceberg: the upper layers. This represents already a very large amount of new information and techniques to learn, and despite the fact that we won’t go deeper there is already an extremely rich range of possibilities that we invite you to discover in these upper layers.

Who should read this guide?

• Integrators, in charge of implementing dynamic templates, adapting built-in features or content types as well as integrating design and layouts, are the primary audience of this document.
• Core Developers, in charge of extending Jahia with advanced features, developing mechanisms to integrate Jahia with third party systems, adding their own java classes, creating new workflows, filters, etc., should also definitely read this guide. All notions explained here need to be understood before trying to extend or change the way the system works in its core.
• Project Managers should definitely read this guide, even if they don’t code (or don’t code anymore) themselves. This guide will familiarize them with the system, understand what is easy or not so easy, what Jahia can do out-of-the box and how their teammates can adapt and customize the platform to match the client’s needs.
• Webmasters with a few technical skills might read this document with some benefits. At least reading the first part will make them more comfortable with the system and capable of talking efficiently with the development team.