MVC staat voor Model-View-Controller.  In ons geval een component in Joomla.

Maar het een programmeer techniek waarbij men de output probeert te scheiden van de techniek.
Zodoende kan ook de techniek en de output door verschillende mensen worden ontwikkeld.
Denk aan een website waar de design afdeling en de programmeurs niet zoheel veel van elkaar hoeven te weten om toch een mooie website af te leveren.

Hieronder een losse vertaling van dit. Ook weer om het in mijn kop te krijgen en misschien heeft de toeallige voorbijganger van deze website er ook wat aan. We gaan een simpele standaard "Hallo wereld" component maken in Joomla.

Model.
Het model is het deel van de component die de applicatie's data omvat.
Het zal vaak functies e.d. herbergen die het mogelijk maken om met data (in een database) te werken, op te halen en te wijzigen enz.
Het zal een lijst met begroetingen uit de database halen. De onderliggende data access techniek zal in het model opgenomen moeten worden.
Als later de data uit een xml bestand moet komen, dan hoeft men alleen de Model aan te passen.

View.
De view zorgd ervoor dat de data die uit de model kom, gerenderd word en klaar gemaakt zodat er mee gewerkt kan worden.
Voor een web-based applicatie zal het voornamenlijk een HTML pagina zijn die teruggegeven word aan de data.
De View haalt data uit de model, welke door de controller word doorgegeven, en zet het dan door naar de template welke aan de gebruiker word getoond. De View doet niks met de data, het laat alleen data zien die door het model word aangeboden.

Controller.
De controller is er verantwoordelijk voor om op de gebruiker te reageren. Dit is meestal, in het geval van een web-based applicatie, een page request.
De controller zal dan bepalen welk verzoek de gebruiker heeft, en hierop reageren door het model aan te spreken, en die de data die nodig is op te halen.
Het model zal deze dan doorgeven aan de view zodat het getoond kan worden.
De controller laat geen data zien, het start alleen methoden welke de data aan zal passen, en dan zal het model naar de vieuw worden doorgegeven welke dan de data zal tonen.

In Joomla is de MVC techniek door drie classes geimplementeerd: JModel, JView, JController. 
Voor meer informatie kan je bij de API reference terrecht (WIP).

Een component maken.

Voor een basis van het component hebben we de volgende bestanden nodig:

• hallo.php - Dit is het beginpunt van ons component
•  controller.php - Onze basis controller.
• views/hallo/view.html.php - dit bestand ontvangt de benodigde data en stopt dat in onze template
• views/hallo/tmpl/default.php - dit is onze template voor de output.
• hallo.xml - is het installatie bestand die verteld waar wat moet komen.

 De bestandsnaam voor het beginpunt moet dezelfde naam hebben als ons component.
Dus als ons componet "com_hallo" heet zal ons startpunt bestand "hallo.php" heten.
Underscores (liggen streepje) _ moet niet worden gebruikt in namen omdat het in Joomla een betekenis kan hebben.

Joomla gebruikt altijd een enkel bestand om te beginnen. index.php voor de Site application en ook voor de administrator kant. 
De applicatie zal de juiste component laden, gebaseerd op de waarde van 'option' in de URL.

Voor ons component zal het er dan zo uitzien:

Het startpunt.

Dit zal ons startbestand laden. components/com_hallo/hallo.php.

De onderstaande code zal je in de meeste componenten terugvinden:

GAF PROBLEMEN DUS EVEN EEN ANDERE KEER DOEN !

Het eerste statement is een beveiligings check.

defined( '_JEXEC' ) or die( 'Restricted access' );

Dan krijgen we het statement dat het pad geeft naar het huidige component.

JPATH_COMPONENT
Als we in het bijzonder de Site of Administartor component pad nodig hebben kunnen we dat met de volgende statements doen:

Site: JPATH_COMPONENT_SITE
Adminsitrator: JPATH_COMPONENT_ADMINISTRATOR.

DS
is de directory seperator van je systeem.Als je dit gebruikt dan maakt het niet meer uit of het / of \ moet zijn (linux of windows) maar regelt het framework van Joomla dat. Dit moeten we altijd gebruiken als we refereren naar directories op de lokale server.

Als we de basis controller hebben geladen, kijken we of een speciale controller nodig is.
In dit component gebruiken we er maar één, maar je weet maar nooit in de toekomst.

JRequest:getVar()

Haalt de waarde op uit de url of de POST data. Als onze url:

Dan kunnen we met  
JRequest:getVar('controller')
De naam van de controller achterhalen.

Nu hebben we onze basis controller: HelloController in com_hello/controller.php, and als we het nodig hebben, kunnen we andere controllers laden.
zoals HelloController2 in com_hello/controllers/controller2.php

 Door gebruikt te maken van de benamingsstandaard, zal het later makkelijker maken voor:
{Componentenname}{Controller}{Controllername}

Nadat de controller gemaakt is, zorgen we ervoor dat hij zijn taak (task) uitvoerd. Zoals dat staat in de URL:

Als die er niet is dan zal de standaard taak uitgevoerd worden: 'display'.
Als deze aangeroepen word dan zal de 'View' variabele bepalen wat er te zien zal zijn.
Andere gebruikelijke opdrachten zijn: 'edit', 'save', 'new'  enzovoort.

De controller beslist dan wel waar de pagina naar toegestuurd (redirect) word, meestal na een opdracht als  'opslaan', het laatste statement:

Tot zover het startpunt. 

 De Controller maken.
Ons componet heeft maar één doel: de wereld begroeten.
Daarom zal de controller erg simpel zijn. Er hoeft geen data gemanipuleerd te worden.
De juiste view hoeft alleen maar geladen te worden. We hebben dus maar één methode in onze controller staan:

Bijna alle functionaliteit die we nodig hebben is in de JController class ingebouwd.
Dus alles wat we moeten doen is de JController::display() methode aanroepen.

De code voor de controller is erg simpel:

jimport('joomla.application.component.controller');

De JController constructor zal altijd een display() taak aanmaken, en als we het niet ander aangeven (met: registerDefaultTask() ), zal de standaard taak worden. De kale display() methode is niet eens nodig omdat het alleen maar de parent contsrutor aanroept, maar het is slim het er toch in te zetten aangezien we dan beter in de code kunnen zien wat er gebeurd. 

De JController::display() methode zal de naam bepalen van de view en de layout op basis van de request en zal deze laden.
Als we een menuitem voor dit componet aanmaken in de administrator kunnen we kiezen welke view we willen zien als we op het menuitem klikken.
Alsook de layout. Een view verwijsd meestal naar een view met een bepaald soort data: een lijst met auto's, of evenementen, of een enkele auto. De layout is de manier waarop deze data getoond word. In ons component is een enkele view en een enkele layout (default).

Het maken van de View

De taak van de view is erg makkelijk: het krijgt de data, en laat deze zien. Deze data word in de Template gestopt met de:
JView::assignRef  methode.

Eerst pakken we de standaard class om daar onze eigen functionalitet bovenop te zetten.

defined( '_JEXEC' ) or die( 'Restricted access' );
 
jimport( 'joomla.application.component.view');
 
class HelloViewHello extends JView
{
    function display($tpl = null)
    {
        $greeting = "Hello World!";
        $this->assignRef( 'greeting', $greeting );
 
        parent::display($tpl);
    }
}

Het maken van de Template

Joomla Templates/layouts zijn gewone PhP bestanden die gebruikt worden om de layout van de data van de view te regelen in een bepaalde manier.
De variabele die toegewezen door de JView::assignRef methode kan in de tempate opgevraagd worden met:

In onze template is het vrij simpel, daar willen we alleen de groet zien die door de view is meegeven:

<?php echo $this->greeting; ?>

een voorbeeld van de template kan je hier (popup) zien. 

Het maken van het XML Installatie bestand.

 Dan moeten we alleen het XML installatie bestand nog maken. Hier staat allerlei installatie gegevens in:

• Wat omschrijvende gegevens over wie het gemaakt heeft, welke versie het is enz.
• een lijst met bestanden die gekopieerd moeten worden.
• Optioneel is een php bestand dat install en uninstall operaties kan uitvoeren.
• Optioneel: een SQL bestand dat database queries zal gaan doen als er geinstalleerd word.

Een voorbeeld van dergelijk XML bestand kan je hier  (popup) zien.

Er worden vaak ook index.html bestanden in directories gezet waar de views of templates e.d. staan.
In deze bestanden staat vaak alleen wat droge html code die een lege pagina laten zien.
Dit is om te voorkomen dat men van buitenaf een directorie overzicht kan zien, als de webserver niet goed geconfigureerd is.
Als men dan naar de directorie toe probeert te browsen ziet men alleen een lege pagina.
Een webserver zoekt namenlijk altijd eerst naar een index.* pagina. Als die er niet is wil een slecht geconfigureerde webserver nog wel eens
de inhoudt laten zien van de directorie.

We gaan verder in Deel II.