FLUIDTEMPLATE¶

An object of type FLUIDTEMPLATE combines TypoScript with the Fluid templating engine.

A FLUIDTEMPLATE object generates content using Fluid templates. It can be used in content elements or to generate content in the top-level page object (see the example on this page).

New in version 13.1

Starting with TYPO3 v13.1 you can use the PAGEVIEW content object for templates on page-level. It reduces the amount of TypoScript needed to render a page in the TYPO3 frontend.

See section Migration from FLUIDTEMPLATE to PAGEVIEW.

Table of content

Data available in Fluid templates¶

The following data is available in the Fluid template:

The content of the current data array.
- At page level it contains the current page record.
- If the FLUIDTEMPLATE is used in the context of the Fluid ViewHelper <f:cObject> it contains data in the Fluid Property data.
- If called in the context of Extbase it contains the data assigned to the view in the Controller.
The settings array set by the parameter settings
Variables in the variables setting
Data retrieved by data processors

You can use the debug ViewHelper to output all available data using the magic {_all} variable:

<f:debug>{_all}</f:debug>

Properties¶

Name	Type
cache	cache
dataProcessing	array of class references by full namespace
extbase.controllerActionName	string / stdWrap
extbase.controllerExtensionName	string / stdWrap
extbase.controllerName	string / stdWrap
extbase.pluginName	string / stdWrap
file	string / stdWrap
format	keyword / stdWrap
layoutRootPath	path / stdWrap
layoutRootPaths	array of path with stdWrap
partialRootPath	path / stdWrap
partialRootPaths	array of path with stdWrap
settings	array of keys
stdWrap	->stdWrap
template	cObject
templateName	string / stdWrap
templateRootPath	file path /stdWrap
templateRootPaths	array of file paths with stdWrap
variables	(array of cObjects)

cache ¶

Type: cache

See cache function description for details.

dataProcessing ¶

Type: array of class references by full namespace

Add one or more processors to manipulate the $data variable of the currently rendered content object, such as tt_content or page. Use the sub-property options to pass parameters to the processor class.

Note

This content was moved to the subpage dataProcessing.

extbase.controllerActionName ¶

Type: string / stdWrap

Sets the name of the action.

extbase.controllerExtensionName ¶

Type: string / stdWrap

Sets the extension name of the controller.

Warning

Up to TYPO3 v11, this property could be used as an alternative to the extensionName argument in the f:translate and f:uri.resource ViewHelpers, provided that translations and public images were stored in the usual paths in your extension.

Since TYPO3 v12 this is no longer supported and it is recommended to either use absolute keys:

<f:translate key="LLL:EXT:my_extension/Resources/Private/Language/locallang.xlf:myKey" />

or the extensionName argument plus key argument in the ViewHelper:

<f:translate key="myKey" extensionName="MyExtension" />

extbase.controllerName ¶

Type: string / stdWrap

Sets the name of the controller.

extbase.pluginName ¶

Type: string / stdWrap

Sets variables for initializing extbase.

file ¶

Type: string / stdWrap

The fluid template file. It is an alternative to ".template" and is used only if ".template" is not set.

Example:

EXT:site_package/Configuration/TypoScript/setup.typoscript

page = PAGE
page {
   10 = FLUIDTEMPLATE
   10 {
      file = EXT:site_package/Resources/Private/Templates/Page/MyTemplate.html
   }
}

format ¶

Type: keyword / stdWrap
Default: html

format sets the format of the current request. It can be something like "html", "xml", "png", "json" or even "rss.xml" or something similar.

layoutRootPath ¶

Type: path / stdWrap

Sets a specific layout path, usually EXT:my_extension/Resources/Private/Layouts/ or a folder below that path.

Note

It is recommended to use Properties (note the plural "s") as it can easily be extended by custom templates in the sitepackage.

layoutRootPaths ¶

Type: array of path with stdWrap

Note

Note the plural -s in "layoutRootPaths"!

Note

If you want to extend layoutRootPaths conditionally, best practice is to use Conditions instead of the "if" function.

Used to define several paths for layouts, which will be tried in reversed order (the paths are searched from bottom to top). The first folder where the desired layout is found is used. If the array keys are numeric, they are first sorted and then tried in reversed order.

Example:

EXT:site_package/Configuration/TypoScript/setup.typoscript

page {
   10 = FLUIDTEMPLATE
   10 {
      file = EXT:site_default/Resources/Private/Templates/Main.html
      layoutRootPaths {
         10 = EXT:site_default/Resources/Private/Layouts
         20 = EXT:site_modification/Resources/Private/Layouts
      }
   }
}

If property layoutRootPath (singular) is also used, it will be placed as the first option in the list of fall back paths.

partialRootPath ¶

Type: path / stdWrap

Sets a specific partial path, usually EXT:my_extension/Resources/Private/Partials/ or a folder below that path.

Note

It is recommended to use Properties (note the plural "s") as it can be easily extended by custom templates provided by the sitepackage.

partialRootPaths ¶

Type: array of path with stdWrap

Note

Note the plural -s in "partialRootPaths"!

Note

If you want to extend partialRootPaths conditionally, best practice is to use Conditions instead of the "if" function.

Used to define several paths for partials, which will be tried in reverse order. The first folder where the desired partial is found is used. The keys of the array define the order.

See layoutRootPaths for more details.

settings ¶

Type: array of keys

Sets the settings array in the fluid template. The value can then be used in the view.

Example:

EXT:site_package/Configuration/TypoScript/setup.typoscript

page = PAGE
page {
   10 = FLUIDTEMPLATE
   10 {
      file = EXT:site_default/Resources/Private/Templates/MyTemplate.html
      settings {
         copyrightYear = 2013
      }
   }
}

To access copyrightYear in the template file use:

{settings.copyrightYear}

Apart from setting a key-value pair as in the example, you can also reference objects or access constants.

stdWrap ¶

Type: ->stdWrap

Provides the usual stdWrap functionality.

template ¶

Type: cObject

Use this property to define the content object which should be used as a template file. It is an alternative to ".file"; if ".template" is set, it takes precedence.

Warning

The FILE object type has been removed in TYPO3 v10. As the .template property used FILE, you should generally check your code to see if this is used and switch to using .templateName with .templateRootPaths or use .file.

templateName ¶

Type: string / stdWrap

This name is used together with the set format to find the template in the templateRootPaths. Use this property to define a content object to use as a template file. It is an alternative to .file. If .templateName is set, it takes precedence.

Example 1:

EXT:site_package/Configuration/TypoScript/setup.typoscript

lib.stdContent = FLUIDTEMPLATE
lib.stdContent {
   templateName = Default
   layoutRootPaths {
      10 = EXT:frontend/Resources/Private/Layouts
      20 = EXT:sitemodification/Resources/Private/Layouts
   }
   partialRootPaths {
      10 = EXT:frontend/Resources/Private/Partials
      20 = EXT:sitemodification/Resources/Private/Partials
   }
   templateRootPaths {
      10 = EXT:frontend/Resources/Private/Templates
      20 = EXT:sitemodification/Resources/Private/Templates
   }
   variables {
      foo = TEXT
      foo.value = bar
   }
}

Example 2:

EXT:site_package/Configuration/TypoScript/setup.typoscript

lib.stdContent = FLUIDTEMPLATE
lib.stdContent {
   templateName = TEXT
   templateName.stdWrap {
      cObject = TEXT
      cObject {
         data = levelfield:-2,backend_layout_next_level,slide
         override.field = backend_layout
         split {
            token = frontend__
            1.current = 1
            1.wrap = |
         }
      }
      ifEmpty = Default
   }
   layoutRootPaths {
      10 = EXT:frontend/Resources/Private/Layouts
      20 = EXT:sitemodification/Resources/Private/Layouts
   }
   partialRootPaths {
      10 = EXT:frontend/Resources/Private/Partials
      20 = EXT:sitemodification/Resources/Private/Partials
   }
   templateRootPaths {
      10 = EXT:frontend/Resources/Private/Templates
      20 = EXT:sitemodification/Resources/Private/Templates
   }
   variables {
      foo = bar
   }
}

templateRootPath ¶

Type: file path /stdWrap

Sets a specific template path, usually EXT:my_extension/Resources/Private/Templates/ or a folder below that path.

Note

It is recommended to use Properties (note the plural "s") as it can be easily extended by custom templates provided by the sitepackage.

templateRootPaths ¶

Type: array of file paths with stdWrap

Note

Note the plural -s in "templateRootPaths"!

Note

If you want to extend templateRootPaths conditionally, best practice is to use Conditions instead of the "if" function.

Used to define several paths for templates, which will be tried in reverse order (the paths are searched from bottom to top). The first folder where the desired layout is found is used. If the array keys are numeric, they are first sorted and then tried in reverse order.

Useful in combination with the templateName property.

Example:

EXT:site_package/Configuration/TypoScript/setup.typoscript

page {
   10 = FLUIDTEMPLATE
   10 {
      templateName = Default
      templateRootPaths {
         10 = EXT:sitedesign/Resources/Private/Templates
         20 = EXT:sitemodification/Resources/Private/Templates
      }
   }
}

variables ¶

Type: (array of cObjects)

Sets the variables that will be available in the fluid template. The keys are the variable names in Fluid.

Reserved variables are "data" and "current", which are set automatically to the current data set.

Example¶

New in version 13.1

It is recommended to use PAGEVIEW for page templates starting with TYPO3 v13.1. See How to migrate to PAGEVIEW

The Fluid template in EXT:my_sitepackage/Resources/Private/Templates/MyTemplate.html could look like this:

EXT:my_sitepackage/Resources/Private/Templates/MyTemplate.html

<h1>{data.title}<f:if condition="{data.subtitle}">, {data.subtitle}</f:if></h1>
<h3>{mylabel}</h3>
<f:format.html>{data.bodytext}</f:format.html>
<p>&copy; {settings.copyrightYear}</p>

You could use it with TypoScript code like this:

Before migration, EXT:my_sitepackage/Configuration/TypoScript/setup.typoscript

page = PAGE
page.10 = FLUIDTEMPLATE
page.10 {
   templateName = MyTemplate
   templateRootPaths {
      10 = EXT:my_sitepackage/Resources/Private/Templates
   }
   partialRootPaths {
      10 = EXT:my_sitepackage/Resources/Private/Partials
   }
   variables {
      mylabel = TEXT
      mylabel.value = Label coming from TypoScript!
   }
   settings {
      # Get the copyright year from a TypoScript constant.
      copyrightYear = {$year}
   }
}

As a result, the page title and the label from TypoScript will be inserted as titles. The copyright year will be taken from the TypoScript constant "year".

Migration from `FLUIDTEMPLATE` to `PAGEVIEW`¶

Before migration, EXT:my_sitepackage/Configuration/TypoScript/setup.typoscript

page = PAGE
page {
    10 = FLUIDTEMPLATE
    10 {
        templateName = TEXT
        templateName {
            stdWrap {
                cObject = TEXT
                cObject {
                    data = levelfield:-2, backend_layout_next_level, slide
                    override {
                        field = backend_layout
                    }

                    split {
                        token = pagets__
                        1 {
                            current = 1
                            wrap = |
                        }
                    }
                }

                ifEmpty = Standard
            }
        }

        templateRootPaths {
            100 = EXT:my_sitepackage/Resources/Private/Templates/Pages/
        }

        partialRootPaths {
            100 = EXT:my_sitepackage/Resources/Private/Partials/Pages/
        }

        layoutRootPaths {
            100 = EXT:my_sitepackage/Resources/Private/Layouts/Pages/
        }

        variables {
            pageUid = TEXT
            pageUid.data = page:uid

            pageTitle = TEXT
            pageTitle.data = page:title

            pageSubtitle = TEXT
            pageSubtitle.data = page:subtitle

            parentPageTitle = TEXT
            parentPageTitle.data = levelfield:-1:title
        }

        dataProcessing {
            10 = menu
            10.as = mainMenu
        }
    }
}

After migration, EXT:my_sitepackage/Configuration/TypoScript/setup.typoscript

page = PAGE
page {
    10 = PAGEVIEW
    10 {
        paths {
            100 = EXT:my_sitepackage/Resources/Private/Templates/
        }
        variables {
            parentPageTitle = TEXT
            parentPageTitle.data = levelfield:-1:title
        }
        dataProcessing {
            10 = menu
            10.as = mainMenu
        }
    }
}

In Fluid, the pageUid is available as {page.uid} and pageTitle as {page.title}, the subtitle with {page.subtitle}.

In this example some Fluid templates have to be moved:

EXT:my_sitepackage/Resources/Private/Templates/Pages/: The page templates can stay in this folder.
EXT:my_sitepackage/Resources/Private/Partials/Pages/: Move files to EXT:my_sitepackage/Resources/Private/Templates/Partials/
EXT:my_sitepackage/Resources/Private/Layouts/Pages/: Move files to EXT:my_sitepackage/Resources/Private/Templates/Layouts/

If the Private folder previously looked like this:

EXT:my_sitepackage/Resources/Private/
- Languages
- Layouts
  - Pages
- Partials
  - Pages
- Templates
  - Pages

It should look like this afterwards:

EXT:my_sitepackage/Resources/Private/
- Languages
- Templates
  - Layouts
  - Pages
  - Partials

FLUIDTEMPLATE¶

Data available in Fluid templates¶

Properties¶

Example¶

Migration from FLUIDTEMPLATE to PAGEVIEW¶

Migration from `FLUIDTEMPLATE` to `PAGEVIEW`¶