We hebben nu onze controllers al maar al wat we krijgen is een simpele tekst. In deel 3 gaan we een layout toevoegen en leer je de View van het MVC model wat beter kennen. Kennis van template parsers is goed meegenomen.
Dankzij de gratis templates van http://www.devarea.nl moeten we niet te ver gaan zoeken achter een goed layout. Je kan hem downloaden door op de volgende link te klikken. Je vind er 4 bestanden (header.phtml, footer.phtml, menu.phtml en layout.css). De linken zijn al gelegd in het menu (zie deel 2: controllers). De extensie wordt in punt 2 uitgelegd.
Over naar punt 2, hier gaan we de templates bouwen en juist plaatsen.
Opmerking! Mensen die deze tutorial al gelezen hebben, moeten het $this->view->url gedeelte nogmaals overlezen omdat ik hiervoor een update heb! Gelieve ook menu.phtml aan te passen met volgende code: http://www.plaatscode.be/6233/!
2. Templates bouwen en organiseren
Laat me eerst beginnen met de extensie. Het view gedeelte van Zend framework gebruikt de extensie phtml om aan te tonen dat het gaat om een template. phtml is een samenvoegsel van php en html. Dit gaat later duidelijk worden waarom.
Het eerste wat er gebeurt is een nieuwe map maken. Iedere controller krijgt zijn eigen map waarin de templates komen voor de verschillende acties. Als je naar de map ./application/views/ gaat zie je 3 mappen staan (zie deel 1). Open de map scripts. Hierin maak je een nieuwe map. Deze geef je de naam index. Dat is de naam van de controller (let op de schrijfwijze: kleine letters). Je maakt ook een map aan voor de GalleryController. We hebben nu 2 mappen in de map scripts (index en gallery).
Je hebt de 4 bestanden gedownload en uitgepakt ergens op je computer (of server). Volgende lijst bevat het bestand en de locatie waar dat bestand moet staan:
layout.css: /public/styles/
header.phtml: /application/views/scripts/
footer.pthml: /application/views/scripts/
menu.phtml: /application/views/scripts/
We gaan nu onze eerste pagina maken. De eerste pagina is de indexAction van IndexController. Dus we gaan onze code opslaan in de map ./application/views/scripts/index/ en geven de template de naam index.phtml (de naam van de action, kleine letters!).
code uitleg:
- $this->render(...): de bestanden die we zonet in de /scripts/ map geplaatst hebben worden in de template toegevoegd en weergeven op het scherm. De functie render zorgt ervoor dat we daadwerkelijk iets op het scherm te zien zullen krijgen.
- echo $this->titel: net zoals andere template parsers kan je variablen plaatsen in je templates. In templatepower is dit zo: {titel} en in zend framework zijn dit php variablen. $this is een instantie van de View class in zend framework. Je gaat in het volgende punt hier meer van verstaan.
In de templates kan je dus dynamische content plaatsen. Je kan gebruik maken van alle code syntacs. Je kan while lussen maken, voorwaarden maken met if/else, ... (een template parser in zijn eenvoud maar o zo goed).
Onze template is gebouwd maar wat nu? In punt 3 gaan we de templates leven inblazen.
3. De controllers laten de views leven
We hebben nog maar één template voor de indexAction in de IndexController. We gaan de IndexController.php openen. We voegen volgende functie toe aan onze IndexController class.
IndexController.php: public function init() { $this->initView(); }
De init functie wordt altijd aangeroepen alvoors de action functie wordt aangeroepen. Hierin kunnen we objecten maken of initialiseren. We initialiseren nu het View gedeelte van Zend framework. Je kan het ook moeilijker maken en via Zend_Loader::loadClass('Zend_View'); de class inladen en daarna een instantie maken in iedere actie. Jij verkiest, maar deze manier is toch handiger en korter.
In de bestanden header, footer en menu.phtml staan ook template variablen. Wanneer je de templates opent vind je volgende variablen terug:
paginaTitel
stylesPath
url
Omdat we die maar één keer willen schrijven, schrijven we ze direct in de init functie. Je init functie zal er nu zo uitzien (uitleg staat eronder):
IndexController.php public function init() { $this->initView();
//variablen declaren in header,menu en footer $this->view->url = $this->_request->getBaseUrl(); $this->view->stylesPath = $this->view->url . '/public/styles/'; }
code uitleg:
In de templates staat er echo $this->url. Nu zei ik al dat $this een instantie is van de view component. Wanneer we de view initialiseren in de controller dan is $this->view ook een instantie van de view component. Dit betekend dat ze beide naar dezelfde class verwijzen. Dus wanneer je een variable $this->mijnVariable; zet in een template dan moet je in je controller $this->view->mijnVariable gebruiken om inhoud te geven aan die variable of om de variable inhoud te veranderen.
Note: de template variable paginaTitel is niet toegevoegd in de init functie omdat deze verschilt per action (zie volgend punt).
3.1. De indexAction()
Nu gaan we de andere variablen declareren en de template op het scherm "toveren". In de indexAction() staat nu een echo. Deze mag je weg doen en volgende code plakken/typen in de plaats.
code uitleg:
- De variablen declareren is niets nieuws meer voor jou.
- $this->render(): je moet hier niet index.phtml of iets anders in plaatsen. De view component zal automatisch de index.phtml vinden in de ./application/views/scripts/index/ map. Hiermee wordt de complete layout getoont op het scherm.
Wanneer je nu naar je website gaat, zie je dat de layout mooi op je scherm staat. Zijn er foutmeldingen of wordt de layout niet mooi weergegeven? Kijk of je template variable url correct ingevuld is (de / niet vergeten op het einde). Staan je templates correct?
Werkt het nog steeds niet? Zet dan de noViewRenderer parameter op false in de bootstrap.
4. Helpers
In de views map staan er ook nog andere twee mappen: filters en helpers. De map filters blijft voor mij nog een groot vraagteken omdat hier niets over geschreven wordt in het framework manual. Er is wel een Filter component en misschien dat dit een locatie is waar je eigen gemaakte filters in kan opslaan (bij mij werkte dit niet echt goed). Helpers daarentegen maken het ontwikkelen echt een plezier. Weg met al dat HTML getyp, leve de helpers.
Helpers helpen je templates sneller schrijven. Een voorbeeld:
Zoals je ziet wordt de template variable titel ge-escaped, dus “ wordt ”. De functie escape is een Helper. Hieronder staat een lijst met alle beschikbare Helpers en de uitleg:
declareVars(): hiermee kan je template variablen declareren zonder dat ze al een inhoud hebben.
formButton($name, $value, $attribs): maak een formulier knop. $attribs is een array.
formCheckbox($name, $value, $attribs, $options): maak een checkboxelement . $options is een array waarin de eerste value een vinkje (waarde: 1) krijgt.
formFile($name, $value, $attribs): maak een file element.
formHidden($name, $value, $attribs): maak een hidden element.
formLabel($name, $value, $attribs): maak een label element.
formPassword($name, $value, $attribs): maak een password element.
formRadio($name, $value, $attribs, $options): maak een radio element.
formReset($name, $value, $attribs): maak een reset knop.
formSelect($name, $value, $attribs, $options): maak een select element. $options zijn de options.
formSubmit($name, $value, $attribs): maak een submit knop.
formText($name, $value, $attribs): maak een text element.
formTextarea($name, $value, $attribs): maak een textarea element.
url($urlOptions, $name, $reset): maakt een link. $urlOptions zijn de link attributen.
htmlList($items, $ordered, $attribs): maakt een lijst, als $ordered true is dan wordt er een OL gemaakt anders een UL. $items is een array en kan geneste items bevatten.
4.1. Schrijf je eigen Helper
Je kan naast de standaard Helpers ook je eigen Helpers schrijven. Bijvoorbeeld een alert Helper of een colorText Helper. Als voorbeeld gaan we eens een colorText Helper schrijven. Hiermee kan je een kleur geven aan de tekst. Neem een nieuwe php bestand en neem volgende code over:
TextColor.php: <?php class Zend_View_Helper_TextColor {
public function textColor( $tekst , $color = '#000000' ) { return '<span style="color:'.$color.';">' . $tekst . '</span>'; }
}
code uitleg:
- Je maakt een class aan die begint met Zend_View_Helper_ daarna de naam van je Helper (let op de hoofdletters!), zo krijgen we Zend_View_Helper_TextColor.
- De class heeft minstens één functie en die heeft de naam van je Helper (let op de hoofdletters!), zo krijg je dus public function textColor. Het aantal parameters kan je zelf kiezen.
- Er wordt nooit echo of print geplaatst enkel een return.
Je slaat deze op als TextColor.php (let op de hoofdletters!) in de map helper.
Zend Framework zal alle Helpers in de map Helpers automatisch laden, dus hier hoef je niet extra's te schrijven in de controllers of dergelijke.
En zo kan je nu verder gaan uitbreiden en meer Helpers schrijven.
5. De andere templates bouwen
We gaan nu andere templates bouwen. Volgende templates moeten nog gemaakt worden:
index
info.phtml
contact.phtml
gallery
index.phtml
view.phtml
add.phtml
edit.phtml
delete.phtml
Vergeet geen map gallery te maken in de map ./application/views/scripts/ omdat we dit een andere controller is!!!
<div id="pageContent"> <h1><?php echo $this->titel; ?></h1> <p class="block"> Hier vind je wat meer informatie over mijzelf en over mijn werkwijze. </p> </div>
Dit was een grote hap om te verwerken, maar door te spelen met de templates ga je wat meer ervaring opdoen. De header, footer en menu staan apart omdat dit code is die steeds terugkeert in iedere template. Als je iets wilt wijzigen aan het menu moet je het maar één keer aanpassen en geen ontelbaar keer.
Om te controleren of je nog goed bezig bent, een screenshot van de mapstructuur die jij ook zou moeten hebben tot nu toe.
Nu begrijp je alweer wat meer over de V in MVC en zie je dat de Controllers en de Views niet zonder elkaar kunnen.