Translations
Info
All page names need to be in English.
en da  de  fr  it  ja  km  nl  ru  zh

Nl:Ts45min

From TYPO3Wiki
(Redirected from Nl:ts45min)
Jump to: navigation, search
Extension detail information
ts45min_nl
this introduction is to give you a comprehension of how TypoScript works.
documentation state publish document state list
licence OCL
forgeproject
mailinglist
usergroups list of usergroups forDevelopers, forBeginners
author(s) M4rtijn, Kees van der Hall, vele anderen nachtwerkers
TER category doc_tut
dependency

<< Back to Extension manuals page

[edit]


TypoScript in 45 minuten

Extensie Key: doc_tut_ts4_nl

Taal: nl

Sleutelwoorden: forAdmins, forBeginners, forIntermediates

Copyright 2000-2010, Documentatie Team, <documentation@typo3.org>

Dit document is gepubliceerd onder de Open Content Licentie, beschikbaar op http://www.opencontent.org/openpub/

De inhoud van dit document is verbonden met TYPO3 - een GNU/GPL CMS/Framework beschikbaar op www.typo3.org

Officiële documentatie

Dit document maakt deel uit van de officiële TYPO3 documentatie. Het werd goedgekeurd door het TYPO3 Documentatie Team na een peer review process. De lezer mag ervan uitgaan dat de informatie in dit document accuraat is - rapporteer afwijkingen alstublieft aan het Documentatie Team (documentation@typo3.org). Het Documentatie Team probeert de officiële documenten naar best vermogen up-to-date te houden.

Handleiding

Dit document is een handleiding. Handleidingen zijn bedoeld als stap-voor-stap richtlijnen met als specifiek doel om een beginner van begin tot eind door een bepaalde opdracht te helpen. Om effectief leren mogelijk te maken, bieden handleidingen voorbeelden waarmee de behandelde onderwerpen geïllustreerd worden. Handleidingen geven bovendien ook richtlijnen over hoe typische problemen vermeden kunnen worden. Ze belichten ook sleutelconcepten die nuttig zijn voor toekomstig gebruik.

Inleiding

Over dit document

Dit document wil een korte inleiding geven over hoe TypoScript werkt en wat TypoScript eigenlijk is. Het helpt om om de code echt te begrijpen in plaats van slechts te copiëren en te plakken.

Reageren

Voor algemene vragen over de documentatie kan u mailen naar documentation@typo3.org.

Indien u een bug in deze handleiding vindt, meldt dit dan alstublieft in de bug tracker van deze handleiding: https://forge.typo3.org/projects/typo3cms-doc-typoscript-45-minutes/issues

Kwalitatieve documentatie onderhouden vraagt veel werk. Het Documentatie Team is steeds op zoek naar vrijwilligers. Als u graag wil helpen, registreer u dan alstublieft op de documentatie mailing list (typo3.projects.documentation on lists.typo3.org).

TypoScript - snel overzicht

Inleiding

De bedoeling van deze inleiding is niet: “Eindelijk werkt het!” maar eerder “Eindelijk snap ik het!” Deze inleiding wil je dus laten begrijpen hoe TypoScript werkt. Vaak voegen mensen lukraak eigenschappen toe aan objecten, maar voor wie TypoScript kent, is het duidelijk dat zoiets geen goeie werkwijze is. Het bespaart je heel wat tijd als je weet hoe de zaken juist werken. Want zo, naarmate je TypoScript leert kennen, kan je problemen sneller oplossen en win je tijd. De rest is slecht een kwestie van geluk.

Het doel van deze inleiding is niet om een kant-en-klare TYPO3 installatie te hebben op het einde maar wel uit te leggen waarom ze werkt.

Backend Configuratie

TypoScript werkt op heel wat plaatsen. Als TypoScript gebruikt wordt in het Gebruiker/Gebruikersgroep TypoScript veld of in het pagina TypoScript veld, dan worden het uitzicht en het gedrag van de formulieren in de backend aangepast.

De rendering van de frontend wordt bepaald door het TypoScript in het TypoScript template. Dit document gaat énkel over de frontend rendering en TypoSc in het algemeen.

Vereisten

We gaan ervan uit dat de lezer over een werkend TYPO3 systeem beschikt en dat de basishandelingen bekend zijn. Het verschil tussen pagina's en contentelementen wordt hier niet uitgelegd. We gaan ervan uit dat je weet hoe een pagina is samengesteld uit een combinatie van verschillende contentelementen. Voor de zekerheid wijzen we er nog op dat deze contentelementen opgeslagen worden in de tabel tt_content. Het databaseveld “CType” beschrijft met welk contenttype we te maken hebben. Afhankelijk van het CType worden wordt een bepaald masker geladen.

Wie TYPO3 en TypoScript beter wil begrijpen, doet er goed aan een kijkje te nemen in de database. De extensie phpmyadmin laat op een makkelijke en comfortabele manier toe om de database vanuit de backend te benaderen. Zo krijgen we snel een overzicht van de relaties tussen pagina's, tt_content en backend. Merk op dat de PID (pagina ID) staat voor de ID (uniek identificatienummer) van een pagina en de UID voor de unieke ID van een specifieke record.

Waarom TypoScript

Strict gezien is TypoScript een configuratietaal. We kunnen er niet mee programmeren maar we kunnen er vele zaken wel uitgebreid mee configureren. Met TypoScript kunnen we de rendering van de website bepalen. We bepalen er de navigatie mee, sommige vaste content maar ook hoe individuele contentelementen worden weergegeven op een pagina.

TYPO3 is een content management systeem dat content en opmaak wil scheiden van elkaar. TypoScript is de lijm waarmee beiden weer met elkaar verbonden worden. Dankzij TypoScript wordt de content uit de database ingelezen, voorbereid en dan weergegeven in de frontend.

Om een website weer te geven (renderen) moeten we slechts vastleggen welke content en hoe die zal worden weergegeven.

Het wat wordt door de Backend gestuurd - daar worden pagina's met inhoud opgebouwd - welke weergegeven moet worden. Het hoe wordt door TypoScript gestuurd.

Met TypoScript wordt bijvoorbeeld, die verschillende Inhoudselemente bij de weergave vastgesteld, of bijvoorbeeld een div-Container dat een element omsluit of een Heading in <h1> ingesloten wordt.

De TypoScript die ervoor zorgt dat de pagina weergegeven wordt, is opgeslagen in een Main-Template. Hierbij is de Rootlevel-Flag aangevinkt.

Rootlevel.png

Wanneer de weergave van een pagina opgebouwd moet worden, zoekt TYPO3 langs de paginaboom naar boven alle pagina's af, of daar een Main-Template staat.

Meestal bestaat er naast een Main-Template ook nog andere Templates. Hoe die samenwerken kan in de Template-Analyser bekeken worden. Nu gaan we uit van maar een Template.

De syntax van TypoSript is eenvoudig. Aan de linker kant worden de objecten met hun eigenschappen gedefinieert, die dan bepaalde waarden toegewezen worden. Objecten met eigenschappen (die ook weer objecten kunnen bevatten) worden met een punt "." gescheiden.

Het begrip Template

Het begrip Template heeft in TYPO3 een dubbele betekenis. Ten eerste is er de HTML-Template, die als een skelet dient waarin later de inhoud wordt geschreven, ten tweede is er de TypoScript-Template die in de Pagina aangemaakt kan worden.

Een veel voorkomende fout in samenhang met TypoScript-Templates kan er als volgt uitzien:

No template found.png

"No template found": Deze waarschuwing verschijnt, wanneer geen Template met een aangevinkte RootLevel-Flag in paginaboom vanaf deze pagina tot Root-Pagina bestaat. (Wereldbol)

The page is not configured.png

"The page is not configured": Deze waarschuwing verschijnt, wanneer de RootLevel-Flag wel gezet is, maar er bestaat geen PAGE object in de template. Door deze code te copieeren in het SETUP veld is voldoende om het probleem te voorkomen.
TS TypoScript:
page = PAGE
page.10 = TEXT
page.10.value = Hallo Wereld

ook TypoScript is alleen maar een Array

TypoScript wordt intern als PHP-Array opgeslagen. Het wordt gebruikt en geevalueerd door verschillende klassen afhankelijk van het Objekt-Type.
TS TypoScript:
page = PAGE
page.10 = TEXT
page.10.value = Hallo Wereld
page.10.wrap = <h2>|</h2>

Wordt in de volgende PHP-Array omgezet:

PHP script:
$data['page'] = 'PAGE';
$data['page.'][10] = 'TEXT';
$data['page.']['10.']['value'] = 'Hallo Wereld';
$data['page.']['10.']['wrap'] = '<h2>|</h2>';

Bij het vullen van de waarden wordt eerst het object "PAGE" gevuld en is dan opgeslagen in de parameter $data['page.']. Het object "PAGE" zoekt dan naar alle eigenschappen die gedefinieerd zijn. In dit geval vindt het alleen een numerieke waarde "10" die ingevuld is. Een nieuwe object "TEXT" met de parameter $data['page.']['10.'] word gevonden. Het object TEXT kent zelf alleen de parameter "value", en beperkt hiermee de inhoud. Alle volgende parameters worden aan de functie stdWrap doorgegeven (zo is TEXT geimplementeerd, meer over stdWrap enz. later). De eigenschap 'wrap' is bekend en de Tekst "Hallo Wereld" wordt op de positie van het verticale streep ingevuld en teruggegeven.

Deze samenhang is belangrijk voor het begrip van het gedrag van TypoScript. Wanneer bijvoorbeeld TypoScript met de volgende regels uitgebreid wordt:
TS TypoScript:
page.10.mijnEigenFunctie = Aha!
Dan wordt regel als volgt in de PHP-Array opgenomen:
PHP script:
$data['page.']['10.']['mijnEigenFunctie'] = 'Aha!';

Maar het object TEXT noch de voor TEXT gebruikte Functie stdWrap kennen de eigenschap "mijnEigenFunctie". Hierdoor blijft de toevoeging in TypoScript zonder werking.

Ook wanneer de syntaxis correct is, heeft de eigenschap geen invloed - een plausibiliteitscontrole is er in dit geval niet. In het bijzonder in samenhang met de TypoScript Editor moet je daar op letten. Alleen wanneer de vriendelijke Syntax-markering oplicht, betekent niet dat de TypoScript de gewenste waarden bevat. Met deze samenhang moet bij het werken en vooral bij het zoeken naar fouten rekening gehouden worden.

De eerste Stap

In de Setup van de Main-Template wordt de basis van de paginaweergave gedefinieerd.

TypoScript bestaat uit Objecten, die bepaalde eigenschappen hebben. Sommige eigenschappen kunnen tot een nieuw Object samengevoegd worden, ander eigenschappen hebben een bepaalde Functie of definiëren het gedrag van objecten.

Voor de weergave is het Object PAGE verantwoordelijk:

TS TypoScript:
 # het object "mijnpagina" wordt als PAGE Object gedefinieerd.
 mijnpagina = PAGE

 # het bezit de eigenschap typeNum
 mijnpagina.typeNum = 0

 # en een Object "10" dat van het type [[T3Doc:TyposcriptReference/ContentObjects/Text|TEXT]] is.
 mijnpagina.10 = TEXT

 # het object 10 bezit ook een eigenschap waarde 
 mijnpagina.10.value = Hallo Wereld

Het Object PAGE biedt naast een groot aantal eigenschappen, een oneindig aantal van Objecten, die alleen aan de hand van hun nummer geïdentificeerd worden (een zogenoemd Content Tabel). Dat betekent dat ze slechts uit getallen bestaan en bij de weergave in de juiste volgorde gesorteerd worden. Als eerst wordt het Object met het kleinste getal weergegeven, en aan het eind het Object met het grootste getal. De volgorde van de regels in TypoScript is daarbij onbelangrijk.

TS TypoScript:
 mijnpagina.30 = TEXT
 mijnpagina.30.value = Dat is het Einde

 # Bij de het weergeven wordt eerst het Object 10, dan 20 en daarna 30 weergegeven. Een Object 25 wordt overeenkomstig
 # tussen 20 en 30 weergegeven. 
 mijnpagina.20 = TEXT
 mijnpagina.20.value = Ik sta in het midden.

 # Dit is het eerste Object
 mijnpagina.10 = TEXT
 mijnpagina.10.value = Hallo Wereld!

 # hier wordt een 2e pagina-Object voor de Printweergave geproduceerd
 printweergave = PAGE
 printweergave.typeNum = 98
 printweergave.10 = TEXT
 printweergave.10.value = Deze tekst wordt op de printer weergegeven.

Iedere regel wordt intern in een multidimensionale PHP-Array opgeslagen. Ieder Object en iedere eigenschap is daarom eenduidig. Wij kunnen willekeurig veel PAGE-Objecten definiëren, nochtans moet de typeNum eenduidig zijn - voor typeNum moet maar een PAGE-Object bestaan. Bijvoorbeeld wordt met de parameter typeNum = 98 een andere weergave modus getoond. Door typenum kunnen verschillende weergavetypen gedefinieerd worden. In het voorbeeld wordt met de parameter typeNum = 98 een andere weergavemodus gemaakt. Door typenum te gebruiken zijn verschillende weergave typen gedefinieerd worden. Specifiek betekent typeNum = 0 voor de normale HTML-Weergave. De aanroep van HTML luidt dan index.php?id=1 respectievelijk index.php?id=1&type = 98 voor de print weergave. De waarde van &type bepaald welk pagina-object weergegeven wordt. Zo kan in 1 en dezelfde Configuratie tussen print weergave, HTML weergave of ook PDF weergave gewisseld worden. Daarbij kunnen configuraties, die in alle drie de weergaven nodig zijn, daar waar nodig gekopieerd en met kleine aanpassing opgenomen worden in een nieuw object. (bijvoorbeeld kan men de normale pagina inhoud in print weergave gekopieerd worden, maar het menu echter niet.)

Tip: De weergave van dit voorbeeld zal door beide als normale tekst weergegeven worden. In het bijzonder bij weergave formaten als WML moet de HTTP-Header veranderd worden enz. Dat wordt echter hier niet verder behandeld.

Het bovenstaande voorbeeld zou PHP als volgt eruit zien:

PHP script:
 $typoscript['mijnpagina'] = 'PAGE';
 $typoscript['mijnpagina.']['typenum'] = 0;
 $typoscript['mijnpagina.']['10'] = 'TEXT';
 $typoscript['mijnpagina.']['10.']['value'] = 'Hallo Wereld!';
 $typoscript['mijnpagina.']['20'] = 'TEXT';
 $typoscript['mijnpagina.']['20.']['value'] = 'Ik sta in het midden';
 $typoscript['mijnpagina.']['30'] = 'TEXT';
 $typoscript['mijnpagina.']['30.']['value'] = 'Dat is het Einde';

Spaties aan het begin en einde worden door TYPO3 verwijderd (trim()).

Met het = teken hebben wij de eerst eenvoudige toewijzing geleerd: een waarde wordt gezet.

TS TypoScript:
 # = Waarde wordt gezet
 test = TEXT
 test.value = Holla
 
 # < Object wordt gekopieerd
 # mijnpagina.10 gibt "Holla" uit
 mijnpagina.10 < test

 # Object, dat gekopieerd werd, wordt veranderd
 # Verandering heeft geen uitwerking op mijnpagina.10
 test.value = Hallo Wereld

 # =< Object wordt aan gerefereerd (naar het Object wordt alleen verwezen)
 test.value = Holla
 mijnpagina.10 =< test

 # Object, waar aan gerefereerd wordt, is veranderd.
 # Verandering heeft een uitwerking op mijnpagina.10 
 # mijnpagina.10 laat "Hallo Wereld" zien
 test.value = Hallo Wereld

Objecten worden altijd met een Hoofdletter geschreven, Parameters en Functies meestal in camelCase (eerste Woord klein, dan alle volgende Woorden met een Hoofdletter, (Uitzonderingen zijn er ook).

Met de . (punt) als scheidingsteken worden Parameter, Functie of Kind-Object aangeroepen en kunnen ook een waarde toegekend worden.

TS TypoScript:
mijnpagina.10.wrap = <h1>|</h1>

Welk Object, Parameter en Functie bestaat, kunnen wij in de TypoScript-Referenz lezen.

Wanneer een aantal Objecten samengevoegd zijn en veel parameters gezet moeten worden, dan ontstaat er veel typewerk.

TS TypoScript:
 mijnpagina = PAGE
 mijnpagina.typenum = 0
 mijnpagina.10 = TEXT
 mijnpagina.10.value = Hallo Wereld
 mijnpagina.10.typolink.parameter = http://www.martinholtz.de/
 mijnpagina.10.typolink.additionalParams = &nix=nix

 # ATagParams houdt zich echter niet aan de "camelCase"
 mijnpagina.10.typolink.ATagParams = class="externewebseite"
 mijnpagina.10.typolink.extTarget = _blank
 mijnpagina.10.typolink.title = De Website van Martin Holtz, de Auteur van deze regels.
 mijnpagina.10.postCObject = HTML
 mijnpagina.10.postCObject.value = Deze Tekst staat ook in de Linktext
 mijnpagina.10.postCObject.value.wrap = |, de postCObject voor de typolink Functie wordt uitgevoerd.

De eenvoud zelf zijn de accolades toegestaan om het object niveau te definiëren, ronde haken om de tekst ook over meerdere regels te schrijven. Bovenstaand voorbeeld kan men ook zo met ronde haken schrijven:

TS TypoScript:
 mijnpagina = PAGE
 mijnpagina {

   typenum = 0
   10 = TEXT
   10 {

      value = Hallo Wereld
      typolink {

         parameter = http://www.martinholtz.de/
         additionalParams = &nix=nix
         # ATagParams houdt zich helaas niet de standaard van "CamelCase"
         ATagParams = class="externewebseite"
         extTarget = _blank
         title = De Website van Martin Holtz, de Auteur van deze regels.
      }
   }

   postCObject = HTML
   postCObject {

      value = Deze tekst staat ook in de Linktext
      value {
         wrap (
            |, zodat het postCObject voor de typolink Funktion wordt uitgevoerd.
         )
      }

   }

 }

De kans op typefouten daalt en het geheel is overzichtelijker. Indien je het Object "mijnpagina" van naam zou veranderen, hoeven alleen de eerste twee regels veranderd te worden en niet alle regels.

Inhoud inlezen

notice - Note

De volgende regels dienen alleen als voorbeeld om de achtergrond te begrijpen en de samenhang. De code wordt door css_styled_content reeds geleverd - er moet daarom niet met hand worden ingegeven. Maar wanneer een bepaald Contenelement geheel anders opgebouwd moet worden, of een zelf gemaakt Extensie zijn eigen Contentelement creert, dan is het noodzakelijk de samenhang te begrijpen.

Wij willen niet alle website inhoud in Typoscript invoeren - dat zou te vermoeiend zijn en de redacteur dat ook niet verplichten.

Daarom maken we een aantal inhoudselementen van het Type "TEXT" aan en maken een TypoScript, die de inhoud automatisch ophaald. Dit voorbeeld maakt een pagina met Kopregels en tekst van alle pagina elementen op de actuele pagina.

Als eerst wordt het PAGE-Object gemaakt, om te zorgen dat het tonen mogelijk wordt gemaakt. In het object PAGE wordt dan op een plaats het Object "10" CONTENT gemaakt, dat weer door verschillende TypoScript-Parameters gestuurd kan worden.

TS TypoScript:
 page = PAGE
 page.typenum = 0
 
 # Het Content-Object voert een database opvraging uit en 
 # laadt de inhoud.
 page.10 = CONTENT
 page.10.table = tt_content
 page.10.select {

      # "sorting" is een Tabelveld in 
      # de Tabel tt_content en bevat 
      # de sorteer volgorde die in 
      # de Backend wordt getoond
      orderBy = sorting

      # Normale Kolom
      where = colPos = 0
 }
 
 # Voor elke uit de database verkregen record
 # word het renderObj uitgevoerd en de interne gegevenstabel 
 # wordt met inhoud gevuld, zodat bijvoorbeeld de bijbehorende waarde van .field 
 # van het juiste veld opgehaald kan worden.
 page.10.renderObj = COA
 page.10.renderObj {

   10 = TEXT

   # In het veld tt_content.header staat de koptekst.
   10.field = header

   10.wrap = <h1>|</h1>

   20 = TEXT

   # In het veld tt_content.bodytext staat de tekst.
   20.field = bodytext

   20.wrap = <p>|</p>
 }

Het Object CONTENT creëert een SQL query uit de Database. De query wordt met "select" gestuurd. Daar wordt gedefinieerd, dat uit de tabel tt_content, gesorteerd op het veld "sorting", alle records uit kolom 0 (dat is de kolom "normal" in de Backend ) wordt uitgelezen. Wanneer de eigenschap pidInList niet is gezet of verwijderd, wordt de opvraging van de actuele pagina beperkt. Dat betekent dat wanneer de pagina met het ID 100 opgeroepen wordt, het CONTENT-Object alleen records geeft, die op de de pagina 100 aangemaakt zijn (pid = 100). De eigenschap renderObj definieert dan, hoe de records worden weergegeven. Daarvoor wordt het COA (Content Object Array) gedefinieerd, dat een willekeurig aantal verschillende TypoScript-Objecten kan opnemen. In dit geval worden twee TEXT-Objecten gedefinieerd, deze worden na elkaar uitgegeven. De record volgorde van de weergave wordt niet bepaald door de record volgorde die in TypoScript is gedefinieerd, maar door de getallen waarmee ze gedefinieerd zijn. Het TEXT-Object "10" wordt daarom voor het TEXT-Object "20" gecreëerd. Indien een Object daar tussen wordt gevoegd, moet een getal tussen 10 en 20 gekozen worden - de positie in TypoScript is daarom onbelangrijk.


De uitdaging bestaat er uit, alle velden die wij in de inhoudselement "Text" hebben uitgegeven, zoals wij ons het als Webdesigner bedacht hebben, daarom moeten wij voor ieder veld (bijvoorbeeld voor foto's, beeld-grootte, beeld-plaats, naar boven, index enx.) in de tt_content tabel een definitie vastleggen.

De onderscheidende inhoudselementen

Wanneer wij nu in plaats van tekst een plaatje willen laten zien, dan moeten wij andere velden uit tt_content gebruiken en deze ook anders laten zien dan pure tekst. Datzelfde geldt voor tekst met plaatje, Koptekst, Lijst, Tabellen enz. Het type Content-Element wordt in het tabelvel tt_content.CType opgeslagen. In het volgende voorbeeld wordt getoond, dat met het Object CASE onderscheiden kan worden, hoe de verschillende inhoudselementen worden opgebouwd.

TS TypoScript:
 10.renderObj = CASE
 10.renderObj {

   # het veld CType wordt voor het onderscheid gebruikt.
   key.field = CType

   # Het Contentype Kopregel wordt intern als "header" opgeslagen.
   header = TEXT
   header.field = header
   header.wrap = <h1>|</h1>

   # Text wordt normaal als tekst gebruikt.
   text = COA
   text {

     10 = TEXT
     # In het veld tt_content.header staat gewoonlijk de kopregel.
     10.field = header
     10.wrap = <h1>|</h1>

     20 = TEXT
     # In het veld tt_content.bodytext staat de tekst.
     20.field = bodytext
     20.wrap = <p>|</p>
   
   }
   
   # ... en hier volgen er nog een paar.
 }

css_styled_content

Dat het moeizaam is, deze zaken steeds weer nieuw te programmeren en in de regel die elementen die steeds gelijk zijn of tenminste hetzelfde functioneren, levert TYPO3 ons enige "statische" Sjablonen (Templates) mee. Dat is momenteel "css_styled_content". Het bevat voor alle mogelijke Contentelementen zinvolle definities.

Het gebruik is eenvoudig vergelijkbaar. De definities zijn als tt_content objecten ter beschikking.

10.renderObj < tt_content

Deze taak is ook de default configuratie van CONTENT-Elements, wanneer ook de static-Template "css_styled_content" bij ingevoegd wordt, dan is het niet meer nodig, de Parameter "renderObj" te zetten.

Voor elk type content element in TYPO3 zijn passende definities in css_styled_content beschikbaar. In de Objektbrowser ziet her als volgt uit:

Object browser tt content case.png

Het kan ook eenvoudig gevolgd worden, hoe ieder content element geconfigureerd wordt. En wanneer een content element geheel anders geconfigureerd moet worden, dan is het nu duidelijk dat dit via tt_content.interne betekenis van het content element gemaakt kan worden. Hier een voorbeeld, hoe de standaard instellingen voor Kopregel overschreven wordt:

TS TypoScript:
 # Dat TYPO3 alles intern in een grote tabel opslaat, zouden de eigenschappen, die niet overschreven worden,
 # behouden blijven en kunnen voor merkwaardige neven effekten kunnen zorgen. Daarom verwijdert men vooraf de oude instellingen.
 tt_content.header >
 
 # Iedere kopregel wordt altijd als h1 getoond, onafhankelijk van de instellinge
 # in het content element
 tt_content.header = TEXT
 tt_content.header.wrap = <h1>|</h1>
 tt_content.header.field = header

Maar niet alleen het renderObj wordt door css_styled_content te beschikking gesteld, maar ook het CONTENT-Objekt.

styles.content.get

TS TypoScript:
 # Onze code tot zover
 page.10 = CONTENT
 page.10.table = tt_content
 page.10.select {

     # De sortering uit de Backend overnemen.
     # Wij kunnen ook een datumveld of de kopregel 
     # of iets anders nemen.
     orderBy = sorting

     # Normale kolom
     where = colPos = 0
 }

Dankzij css_styled_content is de navolgende code voldoende om hetzelfde effect te bereiken:

TS TypoScript:
 # Geeft de kolom normaal (colPos = 0) 
 page.10 < styles.content.get

Als alternatief zijn er voor de andere kolommen ook default definities:

TS TypoScript:
 # De inhoud van de linker kolom weergeven.
 page.10 < styles.content.getLeft
 
 # De inhoud van de rechter kolom weergeven.
 page.10 < styles.content.getRight
 
 # De inhoud van de rand weergeven.
 page.10 < styles.content.getBorder

In de css_styled_content wordt bijvoorbeeld de rand kolom als volgt gedefinieerd:

TS TypoScript:
 # de normale kolom wordt gecopieerd
 styles.content.getBorder < styles.content.get
 
 # en aansluitend wordt allen de kolom positie aangepast.
 styles.content.getBorder.select.where = colPos=3

Een Menu maken

Wij hebben tot nu toe geleerd, hoe de inhoud van een pagina weergegeven kan worden. Er ontbreekt nog de voor een website noodzakelijke navigatie.

Hiervoor biedt TYPO3 een speciaal Menu-Object HMENU (H voor hierarchisch). Op basis van dit Menu kunnen verschillende vormen van menu's opgebouwd worden.

Het menu moet als een niet numerieke lijst opgebouwd worden:

XML / HTML:
<ul>
   <li>op het 1e niveau</li>
   <li>op het 1e niveau
       <ul>
           <li>op het 2e niveau</li>
       </ul>
   </li>
   <li>op het 1e niveau</li>
</ul>

Om niet het overzicht te verliezen, maken we in een nieuwe Sysfolder een Extensie-Sjabloon.

Binnen in dit sjabloon definiëren wij een nieuw Object, die wij later in de Hoofd-Sjabloon kunnen invoegen. Zo kunnen verschillende Objecten eenvoudiger uit elkaar gehouden worden en eenvoudig voor andere projecten gebruikt worden. De extensie Sjabloon wordt in de Hoofd Sjabloon onder "Include basic template:" ingevoegd.

Typisch worden deze objecten als subobjecten van "lib" gedefinieerd. Je kunt ook ieder gewenste en nog niet gebruikte benaming gebruiken.

TS TypoScript:
 lib.textmenu = HMENU
 lib.textmenu {
 
   # Wij definiëren het eerste menu niveau als Textmenu
   1 = TMENU
 
   # Wij definieren de NOrmaal toestand.
   1.NO.allWrap = <li>|</li>
 
   # Wij definieren de ACTieve toestand.
   1.ACT = 1
   1.ACT.wrapItemAndSub = <li>|</li>
 
   # Het gehele menu niveau pakken we in een UL
   1.wrap = <ul class="niveau1">|</ul>

   # Het 2e niveau moet ook zo gemaakt worden.
   # Binnen de accolades kunnen wij ook 
   # Objecten copieëren, als wij met een punt
   # aanwijzen, dat het object binnen de
   # accolades bestaat.
   2 < .1
   2.wrap = <ul class="niveau2">|</ul>
   3 < .1
   3.wrap = <ul class="niveau3">|</ul>
 }

Het object HMENU is een object, dat het mogelijk maakt de verschillende menu's te verwerken. Voor ieder niveau kan een gewenst menu object gebruikt worden, die het renderen van het niveau overneemt. Zo is het mogelijk om het eerste niveau een grafisch menu (GMENU) te tonen en op het 2e en het 3e niveau een Textmenu (TMENU) te tonen. Het 1e menu niveau wordt op 1 gedefinieerd, de 2e op de 2 enz. - Natuurlijk mogen er geen gaten bestaan - wanneer het 3e niveau niet gedefinieerd is wordt ook het 4e niveau niet getoond.

Op ieder menu niveau kunnen voor de verschillende Menu-toestanden (NO="normaal", ACT="Pagina's in de Rootline, d.w.z. actuele pagina's en hun ouders, grootouder, enz. pagina's,", CUR="actuele Pagina" enz.) verschillende definities geconfigureerd worden. Het is belangrijk er op te letten dat buiten de normale toestand ("NO") alle andere toestanden expliciet geactiveerd moeten worden (bijvoorbeeld ACT=1).

Nu kunnen wij dit menu gebruiken en het in onze nieuwe website invoegen:

TS TypoScript:
 page.5 < lib.textmenu

Inhoud een Sjabloon invoegen

Wij hebben gezien, hoe we inhoud kunnen tonen en hoe we menu's kunnen opbouwen, maar een echte website hebben we nog niet.

Wij kunnen de website met COAs samenstellen en het geheel aan HTML kan met TypoScript nagemaakt worden. Maar dat is een kostbare en foutgevoelig bezigheid. Wanneer het HTML-sjabloon ook nog door een Sjabloon-Designer kant en klaar geleverd wordt, dan wordt het - vooral bij iedere wijziging - echt inspannend.

Daarom is er het Element TEMPLATE, waarmee een HTML-Sjabloon ingelezen wordt, in de juiste plaats het menu, de inhoud en nog meer informatie (zoals het logo) ingevoegd kan worden.

TS TypoScript:
 page.10 = TEMPLATE
 page.10 {
  template = FILE
 
  # Wij laden ons HTML-Sjabloon
  template.file = fileadmin/test.tmpl
 
  # Tekstgebieden: 
  # <!-- ###MENU### begin -->
  # Hier staat voorbeeld inhoud als "Platzhalter". Alles tussen de markers wordt
  # door de inhoud van "subparts", in dit geval door de inhoud van
  # Menus, vervangen.
  # <!-- ###MENU### end -->
  subparts {
    MENU < lib.textmenu
    INHALT < styles.content.get
    SPALTERECHTS < styles.content.getRight
  }
 
  # Markers staan op zichzelf, dat betekent het heeft geen begin of eind, maar
  # de Marker wordt direct omgezet.
  # <!-- ###LOGO### -->
  # Wordt door het Logo vervangen..
  marks {
    LOGO = IMAGE

    # De Grafic-file logo*.gif wordt via het Resource veld van 
    # TypoScript Sjabloon invoegen.
    LOGO.file = logo*.gif

    # Het Logo linkt op de website met het ID 1
    LOGO.stdWrap.typolink.parameter = 1
  }
  workOnSubpart = DOCUMENT
 }

Alternatief voor deze aanpak is een Extensie automaketemplate waarmee het mogelijk is, op de Marker te vertrouwen en in plaats van in het ID in te grijpen. Dat maakt een soepele samenwerking met Template ontwikkelaars mogelijk.

Een ander alternatief is templavoila. Zij maakt het mogelijk van een zeer visuele opbouw. De kracht zit op een andere plek en een beginner zal ik TemplaVoila niet aanbevelen.

css_styled_content gebruiken

Dat we de definities van de verschillende Content Elementen van TYPO3 zelf kunnen programmeren, hebben we reeds gezien. Css_styled_content neemt met zijn 2000 regels TypoScript veel werk uit handen. Het is de moeite waard, ook al is het in het begin nog niet zo duidelijk, om TypoScript nader te bekijken: Wij moeten in Typo3 op de pagina staan, waar de Setup-Sjabloon is ingevuld. Dan kiezen bij de module "Slabloon" de "Template Analyzer" uit de keuzebox. Er verschijnt een lijst met actieve en ingevoegde Typoscript-Sjablonen. Deze worden een voor een van boven naar beneden door Typo3 verwerkt en intern tot een grote Configuratie tabel samengevoegd. Met een Klik op "EXT:css_styled_content/static/" wordt de inhoud van het Sjabloon getoond. Eerst zie je de Constanten en daarna de TypoSript Setup. De Extensie css_styled_content zet op alle mogelijke plaatsen een Klasse bij het HTML element. Dit heeft als voordeel, dat het niet meer nodig is, om dit zelf te maken, maar meestal is het voldoende om uit te zoeken welke Klasse welk effect heeft en deze met behulp van CSS aan te passen.

Voorbeeld:
<div class="csc-textpic-imagewrap">...

De benoemingen van de Klassen zijn eenvoudig en - wanneer de Typo3 internals bekend zijn - intuitieef. Alle Klassen beginnen met "csc" en dat staat voor "css_styled_content". Dit wordt bijvoorbeeld gevolgd door "textpic", dat weer het TypoScript Element "textpic" (Text met plaatje) betekent. "imagewrap" betekent dat de Div-Container een plaatje omsluit (wrapt).

Wat er allemaal gebeurd, kan men eenvoudig reconstrueren, als je op een lege pagina een enkel element toevoegt en dan de broncode toepast. In de regel worden bijvoorbeeld de Kopregels doorgenummerd, zodat de eerst kopregel apart behandeld kan worden. Bij tabellen worden de Klassen "even" en "oneven" toegevoegd, zodat het eenvoudig wordt, de tabel van zebra strepen te voorzien. Op dezelfde manier de onderscheidende spaties gebruikt worden. Voor HTML puristen betekent het helaas, dat op veel plaatsen CSS klassen toegevoegd worden, die in het actuele project niet gebruikt zullen worden. Om deze overbodige af te komen, moet bijna de gehele css_styled_content-Extension veranderd worden.

COA Typoscript Object

De Typoscript Objecten worden door passende klassen in TYPO3 geïmplementeerd. Voor de verschillende eisen bij de weergave van een website zijn er verschillende Objecten. Deze objecten hebben dan verschillende eigenschappen. Zo bezit het object IMAGE onder andere een methode wrap en een methode titleText. In de TypoScript-Referentie kan dan de Datentype nagekeken worden, wat dit object voor een waarde verwacht. Bij wrap wordt ook een data type wrap verwacht, ook een tekst die door een pijp (|) gescheiden wordt. Om aan de wrap ander functies te koppelen (bijvoorbeeld wrap.crop = 100) is daarom zinloos. In de praktijk worden dergelijke probeersels gezien - en dat met een blik in de referentie te zien is welke methoden en eigenschappen verwacht worden.

Het object krijgt de parameter zoals boven reeds uitgelegd als PHP tabel aangereikt, (bijvoorbeeld $conf['wrap.']['crop']='100';) deze tabel kan veel gewenste verschillende waarden bevatten, gebruikt wordt alleen die, die het object ook oproept (bijvoorbeeld $conf['wrap'] oder $conf['titleText']).

In het geval titleText is het datatype string / stdWrap, dat betekent dat zowel een een Text (string) als ook een methode van het type stdWrap toegestaan is. Welke eigenschappen stdWrap bezit, kunnen wie weer in de Referentie nalezen. Zodoende kunnen wij op deze plaats deze methode titleText om verschillende eigenschappen uit stdWrap verwijderen (bijvoorbeeld: titleText.field = header). Daarbij wordt de waarde voor titleText als eerste met de normale Text gevuld en daarna wordt de stdWrap Funktie uitgevoerd.

Het is daarom niet nodig, te raden welk Object hoe gemanipuleerd kan worden, zonder dat je deze Informatie in de Referentie na te lezen.

Voor het tonen van een Website zijn echter meerdere Objecten nodig, benötigt, de uitdaging bestaat eruit om deze in de juiste combinatie te gebruiken.

In de paragraaf Inhoud inlezen wordt getoond, hoe met het TypoScript Object CONTENT een opvragin uit de database verwerkt wordt en de inhoud van een pagina uitgelezen wordt. Het Object heeft daarbij een lijst van alle inhoudselementen van een pagina die na elkeer - gewoonlijk op record volgorde - samengesteld wordt. Daarvoor wordt het Object CASE gebruikt, daarbij afhankelijk van het Type van inhoudselement (CType) de weergave op passende wijze opgebouwd wordt.

Het is daarom beslist nodi, de verschillende TypoScript-Objecten en -Functies te kennen.

Objecten, die de database lezen

  • CONTENT biedt de mogelijkheid ook gewenste tabellen binnen TYPO3 te bewerken. Dat betekent niet alleen tt_content maar ook tabellen van Extensies etc. kunnen gelezen werden. De Functie select maakt het mogelijk om complexe SQL-queries te maken.
  • RECORDS biedt de mogelijkheid om bepaalde records op te halen. Zeer handig, wanneer op alle pagina's dezelfde tekst getoond moet worden. Via RECORDS kan dan een bepaald inhoudselement gedefinieerd worden, dat dan aangewezen wordt. Hiermee kan de inhoud van een Redacteur veranderd worden, zonder dat dat element meervoudig gekopieerd moet worden. Dat object wordt ook gebruikt wanner het inhoudselement "Record toevoegen" gebruikt wordt.

In het volgende voorbeeld wordt het E-Mail Adres van het Adres-record getoond en direct als E-Mail Link gemaakt.

TS TypoScript:
page.80 = RECORDS
page.80 {
	source = 1
	tables = tt_address
	conf.tt_address = COA
	conf.tt_address {
		20 = TEXT
		20.field = email
		20.typolink.parameter.field = email
	}
}


  • HMENU leest de paginaboom in en biedt vele comfortabele benaderingen om menu's te tonen. Naast Menu's, die de paginaboom tonen, zijn er ook nog Speciale-Menu's waarmee veel andere dingen omgezet kunnen worden. Deze objecten lezen intern de structuur van het menu in. Hoe het menu opgebouwd wordt, wordt door menu objecten zoals TMENU (Text-Menu) of GMENU (Grafisch-Menu) gedefinieerd. Voor ieder menu niveau kan het object gewisseld worden. Binnen een menu niveau zijn er verschillende menu items. Voor ieder item kunnen weer verschillen waarden gedefinieerd worden (NO=normaal, ACT=Actief een pagina in de Rootline, CUR=Current Page).

Objecten voor het tonen van Inhoud

  • IMAGE de weergave van een beeld.
TS TypoScript:
lib.logo = IMAGE
lib.logo {
  file = fileadmin/logo.gif
  file.width = 200
  stdWrap.typolink.parameter = 1
}

lib.logo bevat nu het logo met een breedte van 200 Pixeln en wordt gelinkt op de pagina met het PID 1.

  • HTML / TEXT voor de weergave van eenvoudig tekst of de inhoud van velden. Een wezenlijk verschil: het HTML-Object implementeert de stdWrap-Functionaliteit op .value.
TS TypoScript:
lib.test1 = TEXT
lib.test1.field = uid

lib.test2 = HTML
lib.test2.value.field = uid
  • FILE importeert direct de inhoud van een bestand.
  • TEMPLATE vervangt in een Sjabloon de Marker door de inhoud.
TS TypoScript:
page.10 = TEMPLATE
page.10 {
  template = FILE
  template.file = fileadmin/test.tmpl
  subparts {
    HELLO = TEXT
    HELLO.value = Vervang de inhoud tussen de beide Markers ###HELLO### en ###HELLO###
  }
  marks {
    Test = TEXT
    Test.value = De Marker "Test" wordt door deze tekst vervangen.
  }
  workOnSubpart = DOCUMENT
}
  • MULTIMEDIA rendert Multimedia Objecten.
  • IMGTEXT biedt de mogelijkheid om binnen tekst beelden te tonen. Wordt gebruikt voor het inhoudselement "Beeld met Tekst"
  • FORM toont een HTML-Formulier.

andere Objecten

  • CASE het Object biedt de mogelijkheid waarden te onderscheiden. In css_styled_content wordt dit Object daarvoor gebruikt afhankelijk van het veld CType het juiste object te rendern.
  • COA- Content Object Array - biedt de mogelijkheid om verschillende objecten samen te voegen.
  • COA_INT - niet gecached. Deze elementen worden bij iedere aanroep opnieuw opgebouwd en berekend. Dit is bijvoorbeeld zinvol voor tijd weergave of gebruikers afhankelijke gegevens.
  • LOAD_REGISTER / RESTORE_REGISTER Dit object biedt de mogelijkheid om de globale tabel $GLOBALS["TSFE"]->register[] met inhoud te vullen. Dit Object zelf geeft niet terug. Het kan enkele waarden maar ook complete TypoScript-Objecten gebruikt worden. Bestand bewerkt het Register als Stack (Stapel), met iedere aanroep wordt een volgende inhoud boven op de stapel geplaatst. Met RESTORE_REGISTER kan je op ieder moment het bovenste element ook weer verwijderen.
  • USER und USER_INT - Gebruiker gedefinieerde Functies, iedere Plugin is zo'n Object. USER_INT is daarbij de niet gecachte variant.
  • IMG_RESOURCE wordt bijvoorbeeld bij IMAGE gebruikt. Het geeft de resource terug, ook de inhoud, die normaal gesproekn in het SRC-Attribuut van de IMG-Tags ingegeven worden. Wanneer beelden geschaald worden, worden door dit object de bestanden berekent en in typo3temp/ opgeslagen.
  • EDITPANEL Dit Object wordt allen ingevoegd, wanneer een Backend-User ingelogd is en voor deze de instelling "Display Edit Icons" in Frontend Admin Panel is gezet. Wanneer het Admin-Panel is ingevoegd, dan worden de pagina's niet meer gecached. Er zijn Icons voor het verplaatsen, redigeren, verwijderen, verstoppen en het aanmaken van records getoons.
  • GIFBUILDER De GIFBUILDER wordt daarvoor gebruikt, GIF-bestanden dynamisch te vertonen. Daarbij kunnen verschillende Texte gecombineerd worden, beelden over elkaar heen gelegd, teksten getoonde worden en veel meer. De GIFBUILDER zelf biedt meer Objecten zoals TEXT of IMAGE, die ongetwijfeld niet de normale TEXT bijvoorbeeld de IMAGE-Objecten aanspreken. Bij het werken met de GIFBUILDER moet ook opgepast worden, dat de Objecten niet verwisseld worden, ook wanneer de naam dezelfde is - de eigenschappen zijn verschillend geïmplementeerd.

Wij hebben hier nog niet alle objecten voorgesteld die in TypoScript bestaan. Wij zijn immers van mening, dat dit de meest belangrijke objecten zijn.

TypoScript Funkties:

TypoScript-Funkties worden gebruikt om de weergave van bepaalde elementen te veranderen en aan te passen. De bekendste functie is de „stdWrap“. Of een element een bepaalde functie implementeert of niet, kan je in de TSref in het hoofdstuk „Data type“ lezen.

Bijvoorbaald cObj (Content Object / Inhoudselement) IMAGE:

Eigenschap: Data type: Description: Default:
file imgResource
imageLinkWrap -> imageLinkWrap [...]
if -> if [...]
altText
titleText
string /stdWrap [...]

In het bovenstaande voorbeeld staat bijv. in de eerst regel (Property = file) de Data type imgResource aangegeven. Dit betekent, dat wij de bestand eigenschap van de Funktie van imgResource kunnen gebruiken.

Vaak worden Funkties ook voor een beter begrip met een kleine pijl voor de naam aangeduid (Zie -> if).

Staat in de regel „Data type“ meerdere door balk gescheiden woorden, dat betekent dit dat meerdere mogelijkheden voorhanden zijn, om dit element te gebruiken. In bovenstaand voorbeeld is dit bij altText en titleText het geval, deze hebben het data type „string“ en „stdWrap“ dat betekent, dat ik een eenvoudige lettercombinatie (String) kan aangeven, en de inhoud met behulp van stdWrap-Funkties kan bewerken (de String wordt met stdWrap bewerkt) of genereren kan (met behulp van stdWrap wordt een ander inhoud opgehaald).


Hier worden een paar belangrijk en veelvuldig gebruikte functies voorgesteld. Daarbij gaat het erom, deze functies voor te stellen, en hun bedoeling te verklaren. Details van deze Functies en alle implementatie eigenschappen vind men in de TSref.


imgResource

De functie voor het data type „imgResource“ richt zich op de modificatie van beelden, zoals de naam al doet vermoeden. Het Object IMAGE bezit de eigenschap "file" die van het data type „imgResource“ is.

Zij bieden bijvoorbeeld de mogelijkheid een beeld in grootte te veranderen,

TS TypoScript:
temp.meinBild = IMAGE
temp.meinBild {

	file = toplogo.gif
 	file.width = 200
	file.height = 300

}


Maximaal grootte (of minimum grootte) aan te geven,

TS TypoScript:
temp.meinBild = IMAGE
temp.meinBild {

	file = toplogo.gif

        # für Maxmialgrößen
 	file.maxW = 200
	file.maxH = 300

	# für Mindestgrößen
	file.minW = 100
	file.minH = 120

}

en zelfs de directe weergave van een ImageMagick-instructie:

TS TypoScript:
temp.meinBild = IMAGE

temp.meinBild {

	file = toplogo.gif
 	file.params = -rotate 90

}


Een van de bekendste en mooiste voorbeelden voor het gebruik van imgResource is het invoegen van dynamischen Beelden uit het Media-Feld in de pagina eigenschappen. Dit heeft als voordeel, dat redacteuren de beelden kunnen veranderen zonder TypoScript te gebruiken en gelijktijdig ook bijvoorbeeld Header-Beelden voor verschillende gebieden met een beetje TypoScript gerealiseerd kan worden:

TS TypoScript:
temp.dynamischerHeader = IMAGE
temp.dynamischerHeader { 
 	file {

		# Pad naar de Import bestanden definiëren
		import = uploads/media/

 		import {

			# wanneer geen beeld op de pagina, dan recursief zoeken tot het beeld is gevonden
			data = level:-1, slide

			# Veld aangeven, waarin het beeld is gedefinieerd
 			field = media

			# aangeven, welk volgnummer van bestand die in het veld aangeroepwn wordt
 			listNum = 0

		}
}


Het pad „uploads/media/“ is het pad, waarin de bestanden worden opgeslagen, welke in de pagina eigenschappen onder „Bestanden“ uploaden kan. Het deel binnen de accolades van „import“ bestaat compleet uit stdWrap-Functies, die hier gebruikt worden, om aan te geven, vanwaar en welk beeld precies geïmporteerd moet worden. Als laatst levert stdWrap hier de bestandsnamen van de beelden die dan uit het Import-Pad (uploads/media) geïmporteerd moeten worden.

imageLinkWrap

Met behulp van de Functie „imageLinkWrap“ creëert men een Link voor het beeld op het PHP-Script „showpic.php“. Dat script opent het beeld in een nieuw venster met vastgelegde parameter, zoals venster achtergrond, beeldgrootte, enz. Deze Functie kan gebruikte worden om „Klick-Vergroten“ voor beelden te creëren (dat betekent ik heb een klein beeld en na een klik wordt een nieuw venster geopend met een beeld in originele grootte.).

TS TypoScript:
temp.meinBild = IMAGE
temp.meinBild {

	file = toplogo.gif
	imageLinkWrap = 1
	imageLinkWrap {

		# ImageLinkWrap activeren

 		enable = 1

		# Body-Tag voor nieuw venster definiëren

 		bodyTag = <body class=“BildOriginal“>

		# Het beeld sluiten (hier sluit een Klik op het beeld het geopende venster)

	 	wrap = <''a href="javascript:close();"> | </a>

		# Breedte van het beeld (m biedt de mogelijkheid van proportioneel schalen)

 		width = 800m

		# Hoogte van het beeld

 		height = 600

		# Een nieuw venster voor het beeld samenstellen

 		JSwindow = 1

		# Voor elk volgend beeld een nieuw venster openen (staat steeds in hetzelfde venster)

 		JSwindow.newWindow = 1

		# Padding (Rand) van het nieuwe venster

 		JSwindow.expand = 17,20
 	}
}

numRows

In TypoScript zijn niet alleen grote en krachtige functies maar ook kleine, machtige functies. Bijvoorbeeld de Functie numRows, die eigenlijk niets anders doet, dan het aantal regels van een select-query teruggeven. Precies zo als het Object CONTENT gebruikt numRows daarvoor de Functie select. De query wordt in beiden gevallen op dezelfde wijze gecreëerd - alleen wordt onderscheiden of het aantal resultaat records wordt teruggegeven, of dat het resultaat zelf wordt teruggegeven.

In samenwerking met de „if“-Functie laat zich hiermee mooie dingen realiseren, zoals bijvoorbeeld een Stylesheet voor de inhoud van de rechter kolom, dat nu geladen wordt, wanneer er in de rechter kolom ook inhoud staat:

TS TypoScript:
temp.headerdata = TEXT
temp.headerdata {
	value = <link rel="stylesheet" type="text/css" href="fileadmin/templates/rechterKolom.css">

	# Wanneer de select tussen accolades minstens 1 regel resultaten teruggeeft, wordt het stylesheet geladen 
	if.isTrue.numRows { 

		# deze pagina testen
 		pidInList = this

		# in de Tabel tt_content
		table = tt_content

		# SQL: WHERE colPos = 2, Nederlands: en kolom = rechts
 		select.where = colPos=2
 	}
}

page.headerData.66 < temp.headerdata

of gelijk een ander Sjabloon, wanneer inhoud in de rechter kolom staat:

TS TypoScript:
temp.maintemplate= COA
temp.maintemplate {

	# 10 wordt alleen opgenomen, wanneer het if-Statement „waar“ teruggeeft
	10 = COA
	10 {
		# de select van boven komt hier als kopie uit css_styled_content
    		if.isTrue.numRows < styles.content.getRight
    	
		10 = TEMPLATE
    		10 { 
      			template = FILE
      			template.file = fileadmin/templates/template-2column.html
    		}
  	}

 	# 20 wordt alleen opgenomen, wanner het if-Statement „waar“ teruggeeft 
	20 = COA
  	20 {
    		if.isFalse.numRows < styles.content.getRight
    		10 = TEMPLATE
    		10 {     
      			template = FILE
      			template.file = fileadmin/templates/template.html
    		}
  	}
}

select

De functie „select“ maakt een SQL SELECT-Query, die gebruikt wordt, om records uit de database te lezen. De select-functie let daarbij automatisch daarop, of die records verborgen, verwijderd of tijdelijk niet beschikbaar zijn. Wanneer pidInList gebruikt wordt (die ook een lijst van pagina's weergeeft), test de functie ook, of de actuele gebruiker het record mag zien.

Met behulp van de select-functie kan je bijvoorbeeld de inhoud van een kolom van een bepaalde pagina op alle pagina's laten zien:

TS TypoScript:
 temp.linkerInhalt = CONTENT
 temp.linkerInhalt {

     table = tt_content
     select {

         # Pagina met ID 123 is de bron
         pidInList = 123

         # Regel volgorde zoals in de Backend getoond
         orderBy = sorting

         # Inhoud van de linker kolom
         where = colPos=1

         # Definieert het veld met de taal-ID in tt_content.
         languageField = sys_language_uid
     }
 }

 # de Marker in het Sjabloon door het tijdelijke object vervangen
 marks.LINKS < temp.linkerInhalt

split

De Split-Functie wordt gebruikt, om de invoer zij een het voorkomen van een bepaald teken te scheiden en de afzonderlijke delen apart te behandelen.

Bij ieder iteratie wordt de actuele index in de sleutel „SPLIT_COUNT“ opgeslagen (beginnend met 0).

Met de hulp van „split“ kan bijvoorbeeld een Tabel veld uitgelezen worden en iedere regel met een zekere Code gewrappt worden (om ggf. een HTML-Tabel met tegels te genereren, wanneer op andere plaatsen dezelfde inhoud niet de tabel gebruikt wordt):

TS TypoScript:
  # Voorbeeld
  20 = TEXT 

  # De inhoud van het veld "bodytext" wordt geïmporteerd (uit $cObj->data-array)
  20.field = bodytext 
  20.split { 

    # het scheidingsteken (char = 10 is de nieuwe-regel) wordt gedefinieerd
    token.char = 10 

    # Er wordt vastgelegd, welk element zal worden gebruikt
    # Over de optionSplit kan hier tussen verschillende elementen
    # onderscheiden worden. Een Een passend element met het nummer moet gedefinieerd sein!
    # Op deze plaats wordt de optionSplit eigenschap gebruikt,
    # er wordt zo afgewisseld dat element 1 en dan element 2 voor Rendern wordt gebruikt - in dit voorbeeld worden
    # afwisselend de regels de klasse "oneven" odf "even" gegeven, zodat een Zebra kleuren kan
    cObjNum = 1 || 2

    # Het 1e element wordt gedefinieerd (waar aan gerefereerd wordt door cObjNum)
    # en de inhoud wordt door middel van stdWrap->current geïmporteerd.
    1.current = 1

    # Het element wordt gewrapt
    1.wrap = <TR class=“odd“><TD valign="top"> | </TD></TR>

    # Het 2e element wordt gedefinieerd en gewrapt
    2.current = 1
    2.wrap = <TR class=“even“><TD valign="top"> | </TD></TR>
  }

  # een algemene Wrap wordt om geheel heen gelegd, om een correcte tabel te maken
  20.wrap = <TABLE border="0" cellpadding="0" cellspacing="3" width="368"> | </TABLE>

if

De moeilijkst TYPO3-Functie is de „if“-Functie, omdat iedereen die een if-constructie in een klassieke programmeertaal kent, deze functie instinctief fout gebruiken zal. Daarom hier een paar voorbeelden en wat die bewerken.

Algemeen geeft die if-Functie „waar“ terug, wanneer alle voorwaarden vervult zijn, het zijn boolsche EN relaties. Wil men, dat de Functie bij vervulling van alle voorwaarden „niet waar“ teruggeeft, kan men de „negate“-Optie gebruiken, het resultaat dus negeren (!(true)).

TS TypoScript:
10 = TEXT

10 {

    # Inhoud van het Textelement
    value = De L-Parameter wordt overgedragen.

    # levert „waar“ en voert tot het tonen van de bovenstaande waarde, wanneer GET/POST-Parameter de L met 
    # een waarde ongelijk 0 afgegeven wordt
    if.isTrue.data = GP:L
}

Met behulp van if is het ook mogelijk waarden te vergelijken. Daarvoor wordt de Parameter if.value gebruikt.

TS TypoScript:
10 = TEXT
10 {

    # LET OP: hier value = value van het Textelements, niet van if
    value = 3 is groter dan 2

    # Vergelijking parameter van de if-Functie
    if.value = 2 

    # LET OP: de regel volgorde is zo gezegd aflopend, dit voorbeeld geeft regel „3 isGreaterThan 2“
    if.isGreaterThan = 3
}

Aangezien de enkele eigenschappen van de if-functie de stdWrap-Functies implementeert, kunnen variabelen van overal hiermee vergeleken worden.

TS TypoScript:
10 = TEXT
10 {

    # Waarde van het Textelement
    value = Het record kan getoond worden, terwijl het start tijdstip voorbij is.

    # Resultaat van voorwaarde vraag
    if.value.data = date:U

    # Voorwaarde, weer omgekeerd lezen: start tijd isLessThan date:U
    if.isLessThan.field = starttime
}

typolink

Typolink is de TYPO3-Functie waarmee men alle mogelijke vormen van Links kan maken. Wanneer het mogelijk is moeten Links met deze functie gemaakt worden, omdat deze dan in TYPO3 „geregistreerd“ zijn – dit is de hypothese hiervoor, dat bijvoorbeeld realURL uit deze Links zoekmachine vriendelijke paden genereerd of daarvoor, dat bij E-Mail-Adressen de Spam bescherming werkt. Wanneer je gewend bent om een <a href=“...“> te gebruiken – doe het niet.

De werking van typolink is wezenlijk zeer eenvoudig. Typolink linkt de aangegeven Text volgens gedefinieerde parameters. Een voorbeeld:

TS TypoScript:
 temp.link = TEXT
 temp.link {

     # dat is de gelinkte Text
     value = Voorbeeldlink

     # hier komt de typolink-Functie
     typolink {

         # waarheen = moet gelinkt worden?
         parameter = http://www.example.com/

         # met welk doel? (_blank hieronder opent een nieuw venster)
         extTarget = _blank

         # een extra Klasse voor de Link, zodat men deze ook kan stylen
         ATagParams = class="linkclass"
     }
 }

Het bovenstaande voorbeeld genereert deze HTML-Code: <a class="linkclass" target="_blank" href="http://www.example.com/" >Voorbeeldlink</a>

Typolink werkt snel zoals een wrap - de inhoud van de waarde die gegeven wordt, wordt door het open en sluiten a-Tag gewrapped. Wanneer de waarde leeg is, dus geen inhoud voorhanden is, wordt automatisch een Text gemaakt.

Bij een link op een pagina worde pagina titel gebruikt, bij een externe URL wordt die URL getoond.

Het voorbeeld kan je ook inkorten, aangezien de „parameter“-Tag van de typolink-Functie al wat denk werk wegneemt. Hier bijvoorbeeld de korte variant, die precies dezelfde link maak, als bovenstaande:

TS TypoScript:
 temp.link2 = TEXT
 temp.link2 {

     # weer de gelinkte Text
     value = Voorbeeldlink

     # de Parameter met de samenvatting van de bovenste Parameter (verklaring staat hier onder)
     typolink.parameter = www.example.com _blank linkclass
 }

De „parameter“-deel van de typolink-Functie analyseert de invoer van bepaalde tekens en loopt afhankelijk van het gevonden teken de verschillende afdelingen langs. In het bijzonder wordt de Parameter-volgorde door de spatie opgedeeld. Wordt zoals in het voorbeeld in het eerste deel een punt dan genereert het een externe Link, vindt het na een Slash „/“ dan genereert het een bestand link, bij een „@“ wordt er en E-Mail-Link gegenereert, bij een eenvoudige Integer-waarde „51“ een link naar de pagina met het ID 51. Met de prefix van het ruitteken „#“ bereikt men een Link naar een bepaald Content-Element (bijvoorbeeld #234 voor een Link het Content-Element met de ID #234 op de actuele pagina, 51#234 voor het Content-Element op de pagina met het ID 51).

Het tweede deel van de parameter beschrijft het doel van de Link. Normaal wordt deze – zoals in het bovenstaande lange voorbeeld getoond – door extTarget (voor externe Links) of doel (voor interne Links) gezet, maar kan door deze 2e parameter overschreven worden.

Het derde deel wordt automatisch in een klasse attribuut voor de Link omgerekend.

Maar moet nu alleen het Klassen attribuut maar niet het doel gezet worden, moet op de plaats van het doel desondanks iets ingevuld worden, aangezien de Functie anders niet herkent dat de Klasse op de derde plaats staat. Wil je geen doel, omdat je het standaard doel wilt gebruiken, echter de Klasse ziet de regel er zo uit (met een Divis „-“ als scheiding):

typolink.parameter = www.example.com – linkclass

Met behulp van de typolink-Functie en het doel attribuut is het ook mogelijk, Links in Javascript-Popups te openen:

TS TypoScript:
temp.link = TEXT

temp.link {

     # der Linktext
     value = Popup-venster openen


     typolink {

          # 1. Parameter = PageID van de doelpagina, 2. Parameter = Grootte van het Javascript-Popups
          parameter = 10 500x400

          # Het title-Tag van de linken
          title = Hier klikken om het Popup te openen

          # de Parameter voor het JS-Window
          JSwindow_params = menubar=0, scrollbars=0, toolbar=0, resizable=1

     }
}

Je moet erop letten, dat veel eigenschappen van typolink van het Type value/stdWrap zijn. Dat betekent het kan waarden berekenen of uit de database lezen.

TS TypoScript:
lib.stdheader >
lib.stdheader = TEXT
lib.stdheader {
   field = header
   typolink.parameter.field = header_link
   wrap = <h2>|</h2>
}

Het kopregel wordt getoond, daarbij wordt een Link gezet op het doel dat in het veld header_link aangegeven is. De eerste regel leegt daarbij de Default-instelling van het css_styled_content.

encapsLines

EncapsLines als afkorting van „encapsulate lines“ of nederlands „Regels inkapselen“ is een TypoScript-Functie waarmee enkel regels als inhoud omsloten kunnen worden. Als of bijvoorbeeld wanneer niets gedefinieerd wordt, een <p> of een <div> om het element moet komen, of geautomatiseerd alle voorkomende van <b> met <strong> vervangen worden.


Een eenvoudig voorbeeld:

In RTE hebben we deze Text aangegeven:

Een eenvoudige Text zonder alles.
  
  
<div class=“myclass“>Een Text met een DIV-Tag eromheen.</div>


In TypoScript hebben we nu deze definitie:

TS TypoScript:
encapsLines {
 
       # definieert, welke Tags als omsluitende Tags gebruikt worden 
       encapsTagList = div,p
 
       # regels, die niet al met Tags van de encapsTagList omsloten zijn, worden met <p>-Tags omsloten
       wrapNonWrappedLines = <p>|</p>
 
       # vervang alle DIV-Tags met P-Tags
       remapTag.DIV = P
 
       # voor het geval een regel leeg kan zijn, geeft een gecodeerde spatie af
       innerStdWrap_all.ifEmpty = &nbsp;
}


Het resultaat ziet als HTML-Code er zo uit:

<p>Een eenvoudige Text zonder alles.</p>

<p>&nbsp;</p>

<p class=“myclass“>Een Text met een DIV-Tag erom heen.</p>


Bij de meeste TYPO3-Projecten zal men deze Functie zelden in de eigen code aantreffen. Maar in css_styled_content zijn enkele settings met deze functie opgenomen, die men wel vaker wil aanpassen. Daarom hier een voorbeeld uit de Standaard configuratie van css_styled_content om de werking te verduidelijken:

TS TypoScript:
lib.parseFunc_RTE {

        nonTypoTagStdWrap.encapsLines {
 
 
               # Omsluitende Tags
               encapsTagList = div,p,pre,h1,h2,h3,h4,h5,h6
 
               # alle DIV-Tags in <p> omzetten
               remapTag.DIV = P
 
               # alle noch niet omsloten regels met <p> wrappen
               nonWrappedTag = P
 
               # lege regels met gecodeerde spatie vervangen
                innerStdWrap_all.ifBlank = &nbsp;
 
               # hier wordt de – vaak beklaagde – Klasse bodytext gezet
               addAttributes.P.class = bodytext
 
               # addAttributes allen zetten, wanneer en nog geen attribuut voorhanden is
               addAttributes.P.class.setOnly=blank
       }
}

Vergelijkt men het onderstaande met het bovenstaande voorbeeld valt het op dat er schijnbaar 2 parameter zijn, die hetzelfde doen. De ene „wrapNonWrappedLines“, en de andere „nonWrappedTag“. Het verschil zit is, dat „nonWrappedTag“ door middel van addAttributes uitgebreid kan worden, terwijl bij „wrapNonWrappedLines“ de complete Wrapping-Tag aangegeven moet worden. Wanneer reeds omsloten regels bijvoorbeel met <p class=“blubb“>|</p> gewrapt zijn, en „wrapNonWrappedLines“ op <p>|</p> staat, geeft dat als resultaat een mengvorm van P-Tags met en zonder Klasse, staat een enkel beeld.

Hier nogmaals duidelijk afgebeeld: Om de vaak lastige class=“bodytext“ te verwijderen, is daar niets meer voor nodig, dan de navolgende regel.

TS TypoScript:
lib.parseFunc_RTE.nonTypoTagStdWrap.encapsLines.addAttributes.P.class >

filelink

Met de Functie „filelink“ creëert men – zoals de naam suggereert – een bestand link. Daarbij wordt niet alleen de Link naar het bestand gecreëerd, maar de filelink biedt ook de mogelijkheid, een Icon naar het bestand en zijn bestandsgrootte tonen.

TS TypoScript:
temp.example = TEXT
temp.example {
	
	# Link labeling en gelijktijdig bestandnaam van het beeld
	value = mein_bild.png

   	filelink {

		# Pad van het bestand
     		path = fileadmin/bilder/

		# bestand moet een Icon krijgen
     		icon = 1
	
		# Het Icon wordt gewrapt
     		icon.wrap = <span class=“icon“>|</span>

		# Het Icon moet ook aan het bestand gelinkt zijn
     		icon_link = 1

		# In tegenstelling tot het symbool voor het data type wordt het bestand als icon getoond, 
                # wanneer het van het type  png of gif is
     		icon_image_ext_list = png,gif

		# De grootte wordt ook getoond
     		size = 1

		# Wrappt de bestandsgrootte (rekening houdend met spaties)
     		size.noTrimWrap = | (| Bytes) |

		# Weergave wordt in Bytes geformatteerd
     		size.bytes = 1

		# Afkortingen voor de verschillende Byte-Grootten
     		size.bytes.labels =  | K| M| G

		# Wrap voor het gehele element
     		stdWrap.wrap = <div class=“filelink“>|</div>
   	}
}

parseFunc

De parseFunc in TYPO3 is niet eenvoudig te verklaren. Het woord parse betekent in Nederlands ontleden.

Deze Functie ontleed het grootste deel van de inhoud, die bijvoorbeeld vie de Rich-Text-Editor is ingevoerd. Zij is er onder ander verantwoordelijk voor, dat zo menig inhoud, die men de RTE ingeeft, niets er op dezelfde manier uitkomt. Enkele standaard ontledingsregels zijn in de extensie „css_styled_content“ reeds voorhanden, een deel daarvan is boven onder „encapsLines“ al beschreven. Wil men bijvoorbeeld veranderen hoe TYPO3 bepaalde elementen wrapt, dan kan men dat meestal met een parseFunc-aanwijzen, will men een Basisfunctie om te zoeken en te vervangen kan men dat met een parseFunc-Aanwijzen. Hier in het voorbeeld wordt ieder vóórkomen van "COMP" in de Frontend veranderd in "Mijn Firmanaam", zo kan men bijvoorbeeld afkortingen automatisch uitschrijven of klein geschreven teksten automatis vergroten:

TS TypoScript:
page.stdWrap.parseFunc.short {
 COMP =  Mijn Firmanaam
 }

De verschillende mogelijkheden om het standaard gedraag aan te passen, vindt men zeer eenvoudig via de TypoScript Object Browser. De verschillende mogelijkheden die bewerking van de invoer verdergaand door parseFunc te laten aanpassen, vindt men in de TSref onder "parseFunc". Zo laat zich snel en eenvoudig de weergave van TYPO3 aan de eigen behoeften aanpassen.

tags

De functie "tags" wordt gebruikt in combinatie met parseFunc om gebruiker gedefinieerde tags te definiëren. Bijvoorbeeld in de extensie "css_styled_content" is een a gebruikers tag om eenvoudige links te creëren.

tags { # Hier wordt de naam van de nieuwe tag gedefinieerd

	link = TEXT

# Hier hoe de tag wordt verwerkt/parsed

	link {
		current = 1

typolink {

 			parameter.data = parameters:allParams

extTarget = {$styles.content.links.extTarget}

target = {$styles.content.links.target}

}

		parseFunc.constants=1
	}

}

Deze functie is speciaal bruikbaar als een bepaald type element vaak wordt gebruikt door editors en wij hun werk eenvoudiger willen maken. Wij zijn in staat om een manier te bieden waardoor editors veel handmatig werk niet steeds opnieuw hoeft te doen. Alleen de tag invoeren en de formattering wordt automatisch uitgevoerd.

== HTMLparser == De HTML-Parser legt vast, hoe de inhoud bewerkt wordt. Hij wordt meestal als subfunctie van [[Ts45min#parseFunc|parseFunc]] gebruikt. Zo kan men bijvoorbeeld vastleggen, dat alle Links absoluut gezet worden (bijvoorbeel voor een Newsletter): page.stdWrap.HTMLparser = 1 page.stdWrap.HTMLparser {

keepNonMatchedTags=1

# hier wordt het Domein gedefinieerd, die voor het relatieve pad gevraagd wordt tags.a.fixAttrib.href.prefixRelPathWith=http://www.example.com/

# voor alle Links zonder gedefinieerd doel wordt hier het doel op _blank gezet tags.a.fixAttrib.target.default=_blank }

De Functie HTMLparser is extreem machtig, aangezien daarmee allerlei inhoud voor de weergave aangepast en veranderd wordt. Zo kunnen ook enkele Tags gedefinieerd worden - intern worden Links bijvoorbeeld in de Form Linktext
</nowiki> opgeslagen. Dat betekent het wordt een eigen Tag gebruikt. Deze Tag kan weer in alle velden - ook kopteksten - gedefinieerd worden, bij een passende Parser gedefinieerd is. Het volgende voorbeeld staat het toe dat <u>-Tag in de kopteksten. Hier wordt de Standaard Definitie uit css_styled_content aangepast. De Functie htmlSpecialChars wordt gedeactiveerd, daarmee dat <u> behouden blijft. Dan wordt de Functie parseFunc gebruikt en gedefinieerd, dat buiten de Tag "u" geen Tags toegestaan zijn. Er worden alle Tags uit de <u>-Tag verwijderd.
TS TypoScript:
# in de koptekst moet een <u>-Tag toegelaten worden,
# naast alle elementen die gewoon geparst worden.
lib.stdheader.10.setCurrent.htmlSpecialChars = 0
lib.stdheader.10.setCurrent.parseFunc {
  allowTags = u
  denyTags = *
  constants=1
  nonTypoTagStdWrap.HTMLparser = 1
  nonTypoTagStdWrap.HTMLparser {
    keepNonMatchedTags=1
    htmlSpecialChars = 2
    allowTags = u
    removeTags = *
  }
}

Bij dit voorbeeld wordt opnieuw duidelijk, hoe belangrijk de functie stdWrap is. De functie setCurrent is van het Type string/stdWrap en maakt het mogelijk die functie parseFunc überhaupt kan worden gebruikt.

stdWrap juist gebuiken

De Functie stdWrap bevat een groot aantal verschillende functies en parameter mogelijkheden. Enkelen zijn triviaal, anderen zijn moeilijk te doorgronden. Op deze plaats zal nogmaals ingegaan worden op het grondprincipe en een paar bijzondere functies/eigenschappen uitgesproken worden.

De stdWrap-Eigenschap kan alleen gebruikt worden, wanneer het expliciet gedefinieerd is. Wanneer een eigenschap van het Type "wrap" is, dan zijn geen stdWrap-eigenschappen voorhanden. In de regel wordt of een eigenschap stdWrap van het Type stdWrap aangeboden, of een eigenschap biedt bijvoorbeeldd "string/stdWrap".

TS TypoScript:
 10 = IMAGE
 10.stdWrap.typolink...

Het Object Image heeft een eigenschap stdWrap van het Type stdWrap.

TS TypoScript:
 10 = HTML
 10.value = Hallo Wereld
 10.value.typolink ...

Het Object HTML daar tegenover heeft een eigenschap waarde van het Type string/stdWrap. Het kan een String toegewezen worden en aanvullend kunnen stdWrap eigenschappen gebruikt worden.

niet de regelvolgorde in TypoScript is bepalend maar de TSref

Een belangrijke beperking moet hier uitgesproken worden: De enkele functies worden in de regelvolgorde, zoals ze in de Referentie aangegeven zijn, uitgevoerd. Wanneer je er niet goed op let, kan het gebeuren, dat enkele resultaten er anders uitzien dan gedacht.

TS TypoScript:
 10 = TEXT
 10.value = Hallo Wereld
 10.case = upper
 10.field = header # we gaan ervan uit dat header "typo3" bevat (in kleine letters!)
 10.stdWrap.wrap = <strong>|</strong>
 
 # laat het volgend zien:
 <STRONG>TYPO3</STRONG>

In dit voorbeeld gebeurt het volgende: Eerst wordt de inhoud van Text-Objects met "Hallo Wereld" gevuld. Omdat de TypoScript-configuratie in een tabel opgeslagen wordt, waarbij de regelvolgorde van de definities niet behouden blijven kan, worden die functies na een stdWrap gedefinieerde regelvolgorde uitgevoerd. Deze regelvolgorde weerspiegeld de Referentie analoog weer. Na een korte blik in de Referentie moet als eerste "field", daarna "stdWrap" (en daarmee "stdWrap.wrap")en eerst als afsluiting "case" uitgevoerd wordt..

stdWrap recursief gebruiken

Omdat immers de stdWrap Functie weer recursief opgeroepen kan worden, is het mogelijk de regelvolgorde daarmee te veranderen.

De functie "prioriCalc" maakt het mogelijk om eenvoudige mathematische formule te berekenen. Wanneer ze op 1 gezet wordt, wordt de inhoud berekentd, waarbij immers een eenvoudig ontbinding van links naar rechts plaats vindt. De volgende Code ziet eruit, als wordt de inhoud van het veld "width" met 20 verhoogd.

TS TypoScript:
 10 = TEXT
 10.field = width   # Annahme: "width" ist 100
 10.wrap = |+20
 10.prioriCalc = 1

Immers is dit niet het geval van het resultaat, dat uitgegeven wordt luidt "100+20". De Functie "prioriCalc" wordt voor de Functie "wrap" opgeroepen en berekend daarom alleen het resultaat van "field", daarom het resultaat "100". Opdat het juiste resultaat "120" afgegeven wordt, moet zekergesteld worden, dat "field" en "wrap" voor "prioriCalc" uitgevoerd worden. Dat wordt met de volgende uitdrukking bereikt:

TS TypoScript:
 10.stdWrap.wrap = |+20

De stdWrap-Functie zelf wordt na "field" maar voor "prioriCalc" uitgevoerd, daarom wordt "100+20" gewrapped en eerst daarna wordt de functie "prioriCalc" uitgevoerd en daarmee de waarde "120" berekend.

het datatype

Enorm belangrijk bij het werken met TypoScript is het, de eigenschap van het datatype, die gebruikt gaat worden, te beschouwen. In het bijzonder bij de stdWrap eigenschap valt in de praktijk weer op, dat de Functies op de een of andere manier gecombineerd worden tot per saldo per toeval het doel bereikt wordt.

Alleen wanneer expliciet de stdWrap-functionaliteit aangegeven is, kunnen stdWrap-functies zoals field, data of typolink ook gebruikt worden.

lang: Meertaligheid

stdWrap beschikt over een eigenschap, waarmee het mogelijk is eenvoudig teksten, die in een pagina met TypoScript ingevoegd is, meertalig om te zetten.

TS TypoScript:
 10 = TEXT
 10.value = Impressum
 10.lang.en = Imprint
 10.typolink.parameter = 10

Ongetwijfeld zijn zulke teksten door externe redacteuren alleen moeilijk te vertalen - juist bij onbekende talen kan dat snel tot een uitdaging leiden. In zo'n geval laat het zich aanzien, de vertaling bij Konstanten voor te nemen. Deze kunnen centraal op een plaats beheerd worden en worden dan in TypoScript ingevoegd.

TS TypoScript:
 # Constants
 text.impressum = Impressum
 text.en.impressum = Imprint

 # Setup
 10 = TEXT
 10.value = {$text.impressum}
 10.lang.en = {$text.en.impressum}
 10.typolink.parameter = 10

Daardoor wordt de vertaling van het eigenlijke TypoScript gescheiden. Perfect is deze oplossing zeker niet - zijn er beter benaderingen?

cObject

De parameter cObject kan daarvoor gebruikt worden, de inhoud door een TypoScript-Object te vervangen. Dat kan een COA, een Plugin of een tekst zoals in dit voorbeeld zijn.

TS TypoScript:
 10.typolink.title.cObject = TEXT
 10.typolink.title.cObject.value = Impressum
 10.typolink.title.cObject.lang.en = Imprint

Outlook

Punten, die we in de volgende versies mogen beschouwen:

  • Het bereik van de menus kunnen nog duidelijk uitgebouwd worden
  • Het samenspel met TemplaVoila moet aangestipt en verduidelijkt worden (vooral de FCEs)
  • TypoScript Debuggen verduidelijken
  • verdere stdWrap functies verduidelijken
  • verduidelijken: record wordt geopend, formulier worden gerendert, dat wordt door TCA en pagina-TS gestuurd, dan wordt opgeslagen, de records landen in de DB ( RTE ook nog verklaren?). Dan wordt de pagina in Frontend opgeroepen en de gegevens voor de weergave wordt door TypoScript gehaald en HTML wordt getoond.
  • Afkortingen, om zijn minst in een glossary verklaren.