Prosty szablon na PatTemplate
PatTemplate jest potężnym i elastycznym systemem, umożliwiającym tworzenie szablonów dla witryn opartych na PHP. Zapoznaj się z tłumaczeniem artykułu Havarda Lindseta: Simple PHP Templates With PatTemplate.

Wprowadzenie

Jeśli kiedykolwiek tworzyłeś duży serwis oparty na PHP, zapewne przekonałeś się, jak niewygodne jest łączenie w skryptach kodu PHP i HTML. Sytuacja komplikuje się, gdy musisz zmodyfikować serwis. Bardzo trudno jest wprowadzać zmiany zarówno w kodzie, jak i układzie graficznym.

W takich przypadkach z pomocą przychodzą systemy szablonów. System szablonów to mechanizm umożliwiający całkowite oddzielenie projektu graficznego (warstwy prezentacji) od kodu aplikacji (warstwy aplikacji i warstwy bazy danych). Ich rozdzielenie sprawia, że kod apliacji jest czytelniejszy, jej konserwacja prostsza i bardziej efektywna, a życie i programistów i twórców WWW łatwiejsze.

Joomla! jest zaprojektowane tak, aby korzystać z systemu patTemplate.

PatTemplate jest potężnym i elastycznym systemem, umożliwiającym tworzenie szablonów dla witryn opartych na PHP. Poniższy artykuł jest tłumaczeniem opracowania Havarda Lindseta. Oryginał znajdziesz pod adresem: Simple PHP Templates With PatTemplate . Autor objaśnia szczegóły i podaje przykłady, jak stosować patTemplate z PHP. Niektóre partie artykułu zostały nieco rozszerzone dodatkowymi objasnieniami.

Kiedy zaczynałem swoje poszukiwania silnika szablonu, który chciałem stosować w swoich serwisach, zależało mi na następujacych cechach:

  • łatwy w użyciu
  • łatwy w nauce
  • wspierany przez różne przeglądarki

Zdecydowałem się na silnik patTemplate, stworzony i rozwijany przez Stephana Schmidta. Możesz pobrać go bezpłatnie z http://www.php-tools.de. Zachęcam Cię do pobrania go, zanim zaczniesz czytać dalej.

Przegląd PatTemplate

Pierwsze, co zauważałem w patTemplate, to prostota stosowania. Tworząc szablon, dzielisz swój dokument na różne części, używając znaczników XML. Oto przykład szablonu:

 
<patTemplate:tmpl name="artykul"> 
  <html> 
    <head> 
      <title>patTemplate: Przyklad szablonu</title> 
   </head> 
   <body> 
     <h3>{NAGLOWEK}</h3> 
     {ZAWARTOSC} 
   </body>  
  </html>
</patTemplate:tmpl>

Podczas analizy tego pliku patTemplate szuka zmiennych i zastępuje je skojarzonymi z nimi wartościami. W tym przypadku {NAGLOWEK} i {ZAWARTOSC} są zmiennymi. Na następnej stronie zobaczymy, jak można wstawiać "wartości" zastępujące te zmienne. Przekonasz się, jak łatwo stworzyć szablon.

Poniżej kilka kluczowych właściwości patTemplate (tłumaczenie ze strony projektu patTemplate):

  • zastosowanie specjalnych znaczników XML oddzielających dokument od szablonu (grafiki)
  • dowolna ilość szablonów na stronie,
  • czytanie z prostych plików HTML
  • zmienne lokalne i globalne
  • automatyczne powtarzanie szablonów tworzących listy (wykazy)
  • automatyczne tworzenie alternatywnych wierszy w wykazach dzięki zastosowaniu szablonu typu OddEven
  • automatyczne numerowanie list
  • szablony mogą zawierać szablony potomne
  • szablony potomne włączane warunkowo
  • usuwanie lub zastępowanie nieużywanych zmiennych HTML
  • ukrywanie/pokazywanie szablonów w dokumencie
  • odczytywanie plików zewnętrznych z parsowaniem i bez parsowania
  • usuwanie białych znaków zmniejszające rozmiar kodu
  • wielokrotne używanie szablonu w dokumencie przez linkowanie
  • cytowanie znaczników szablonu umożliwiające włączanie jednego szablonu w drugi, dzięki czemu wynik przetworzenia drugiego szablonu dołączany jest do części już przetworzonej.
  • tworzenie w dowolnym edytorze ASCI (HTML, txt, XML, LaTex, etc.)

Prosty przykład

Przyjrzyjmy się zaprezentowanemu wcześniej przykładowi. Jest on dość prosty, ale objaśnię każdą jego część:

 
<patTemplate:tmpl name="artykul"> 
  <html> 
    <head> 
      <title>Przyklad patTemplate</title> 
    </head> 
    <body> 
      <h3>{NAGLOWEK}</h3> 
      {ZAWARTOSC} 
    </body> 
  </html> 
</patTemplate:tmpl>

Objaśnijmy kolejne części.

<patTemplate:tmpl name="artykul">

To jest znacznik początkowy definiujący szablon. W tym przypadku składa się on z nawiasu trójkątnego (<), określenia przestrzeni nazw (patTemplate), nazwy znacznika tworzącego szablon (tmpl), atrybutu (name) oraz nawiasu trójkątnego zamykającego (>). Atrybut name określa nazwę szablonu. Nazwa musi być unikalna. Będzie wykorzystywana jako adres szablonu.

 {NAGLOWEK}

To jest zmienna. Zmienne określa miejsce, w którym podczas przetwarzania szablonu zostanie wstawiona faktyczna zawartość, skojarzona ze zmienną. Zmienna musi być zapisana WIELKIMI literami. Może zawierać tylko znaki alfabetu, cyfry i podkreślenia (_). Zawsze jest zamknięta nawiasami klamrowymi

</patTemplate:tmpl>

To jest znacznik końcowy. Wskazuje koniec szablonu patTemplate. Składa się z otwierającego nawiasu trójkątnego, ukośnika, nazwy elementu wraz z określeniem przestrzeni nazw i nawiasu zamykającego. Znacznik końcowy nie zawiera atrybutów, a nazwa elementu musi być dokładnie taka sama, jak umieszczona w znaczniku początkowym. Jeżeli używasz XML, to sens tego znacznika powinien być dla Ciebie oczywisty.

W następnej sekcji zobaczymy, w jaki sposób zastąpić zmienne faktyczną zawartością. Zanim jednak przejdziemy dalej, zapisz powyższy przykład jako "przyklad1.tmpl.html".

W PHP

Tymczasem zróbmy niewielki przeskok i na innym przykładzie zobaczmy, jak stosować patTemplate w PHP:

<?php 
   // Dolacz plik patTemplate
      include("includes/patTemplate.php"); 
   // Zanicjuj klase patTemplate i utworz nowy obiekt 
      $tmpl = new patTemplate(); 
   // Oznacz katalog, w ktorym umieszczono pliki szablonu. 
      $tmpl->setBasedir("templates"); 
   // Wybierz plik szablonu, ktory ma byc przetwarzany. 
      $tmpl->readTemplatesFromFile("przyklad1.tmpl.html"); 
   // Dodaj do szablonu zmienne
      $tmpl->addVar("artykul", "NAGLOWEK", "To jest naglowek"); 
      $tmpl->addVar("artykul", "ZAWARTOSC", "A to jest zawartosc..."); 
   // Przetworz i wypisz szablon
      $tmpl->displayParsedTemplate("artykul"); 
?>

Jak widziesz w powyższym przykładzie, korzystanie z patTemplate jest dość logiczne. Spójrzmy na każdy element powyższego kodu:

// Dolacz plik patTemplate
   include("patTemplate.php");

Ten krok jest zapewne oczywisty. Wszystko, co robi, to włącza plik patTemplate.

   // Zanicjuj klase patTemplate i utworz nowy obiekt 
   $tmpl = new patTemplate();

Ten fragment inicjuje klasę patTemplate klasę i tworzy nowy obiekt - instancję klasy.

  // Oznacz katalog, w ktorym umieszczono pliki szablonu. 
   $tmpl->setBasedir("templates");

Funkcja SetBasedir () wskazuje, w którym miejscu znajdują się pliki z szablonami.

  // Wybierz plik szablonu, ktory ma byc przetwarzany.  
   $tmpl->readTemplatesFromFile("przyklad1.tmpl.html");

Funkcja ReadTemplatesFromFile () wskazuje patTemplate, w którym pliku znajduje się szablon.

// Dodaj do szablonu zmienne 
   $tmpl->addVar("artykul", "NAGLOWEK", "To jest naglowek"); 
   $tmpl->addVar("artykul", "ZAWARTOSC", "A to jest zawartosc...");

Te dwie linie zawierają zmienne, które po przetworzeniu szablonu zostaną zastąpione faktyczną zawartością.

Funkcja AddVar () wymaga trzech parametrów: addVar(nazwa_szablonu, nazwa_zmiennej i wartosc_zmiennej)

// Przetworz (parsuj) i wypisz szablon na ekranie
   $tmpl->displayParsedTemplate("artykul");

Ta funkcja przetwarza szablon (wykonuje wszystkie zawarte w nim instrukcje), a następnie wyświetla go na ekranie.

Po tym wprowadeniu powinieneś rozumieć podstawy działania patTemplate. Dalej przejdziemy do rzeczy nieco bardziej skomplikowanych.

Szablon w pętli

Kolejny interesujący aspekt patTemplate to zdolność sterowania szablonami za pomocą pętli. Może ona być wykorzystywana na przykład, gdy chcesz zaprezentować na stronie powtarzający się rodzaj wyników pobranych z bazy danych.

Zobaczmy przykład:

 
<patTemplate:tmpl name="body"> 
  <html> 
    <head> 
      <title>Wprowadzenie petli</title> 
    </head> 
    <body> 
     <table> 
       <patTemplate:tmpl name="listaimion"> 
         <tr> 
           <td>{IMIE}</td> 
         </tr> 
       </patTemplate:tmpl> 
     </table> 
    </body> 
  </html> 
</patTemplate:tmpl>

Rozumiesz już z objaśnień wcześniejszych, jak skonstruowany jest ten plik i jak będzie działać. Zapisz ten szablon w pliku pod nazwą "przyklad2.tmpl.html".

Spójrzmy teraz na kod PHP, który zawiera tę nową, interesującą nas część:

<?php 
  // Dolacz plik patTemplate
     include("includes/patTemplate.php"); 
  // Zanicjuj klase patTemplate i utworz nowy obiekt 
     $tmpl = new patTemplate(); 
  // Oznacz katalog, w ktorym umieszczono pliki szablonu. 
     $tmpl->setBasedir("templates"); 
  // Wybierz plik szablonu, ktory ma byc przetwarzany. 
     $tmpl->readTemplatesFromFile("przyklad2.tmpl.html"); 
  // Stworz jednowymiarowa tablice 
     $imiona = array("Piotr", "Jacek", "Robert"); 
  // Powtarzaj do wyczerpania listy
     foreach ($imiona as $imie) { 
     // Zastap zmienna wartosciami pobranymi z tablicy  
        $tmpl->addVar("listaimion", "IMIE", $imie); 
        $tmpl->parseTemplate("listaimion", "a"); 
     } 
  // Przetworz i wypisz szablon 
     $tmpl->displayParsedTemplate("body"); 
?>

Mamy tutaj dwa nowe segmenty kodu, przy których się zatrzymamy, aby przeanalizować ich rolę:

// Stworz jednowymiarowa tablice  
     $imiona = array("Piotr", "Jacek", "Robert");

Korzystając z funkcji PHP array(), zastosowaliśmy tablicę, która zostanie przetworzona za pomocą instrukcji pętli foreach i wypełniliśmy ją imionami.

// Powtarzaj do wyczerpania listy
     foreach ($imiona as $imie) { 
      // Zastap zmienna wartosciami pobranymi z tablicy  
         $tmpl->addVar("listaimion", "IMIE", $imie); 
         $tmpl->parseTemplate("listaimion", "a"); 
     }

Funkcja addVar() przypisuje pobrane z tablicy imiona do zmiennej IMIE. Przygotowuje więc przetworzenie zmiennej przez funkcję parseTemplate(). Drugi parametr funkcji parseTemplate() - "a" można by przetłumaczyć jako "dodaj do" lub "dodaj na końcu". Przetwarza ona szablon, dołączając wynik do części już przetworzonej. Efektem jest dołączenie do listy kolejnych imion.

 // Przetworz i wypisz szablon 
   $tmpl->displayParsedTemplate("body");

Szablon "listaimion" jest dzieckiem albo inaczej potomkiem szablonu "body", bo znajduje się wewnątrz niego. Gdy wywołamy funkcję displayParsedTemplate () na rodzicu, wszystkie potome szablony również zostaną przetworzone i wyświetlone.

Typy szablonów

Następną interesującą rzeczą w patTemplate jest możlwość wyboru różnych typów do Twojego szablonu. Wyboru dokonujesz, dodając atrybut deklarujący wybrany typ do znacznika otwierającego <patTemplate:tmpl>.

Możesz wybrać jeden z czterech typów. Objaśnię, co każdy z nich robi wypisami z dokumentacji patTemplate.

Standard

To typ domyślny, wybierany zawsze, gdy atrybut type zostanie pominięty. Innymi słowy możesz ten typ określić tak:

 
<patTemplate:tmpl name="body" type="standard">
To jest szablon.
</patTemplate:tmpl>

albo pominąć atrybut zupełnie:

 
<patTemplate:tmpl name="body">
To jest szablon.
</patTemplate:tmpl>

Oba zapisy przynisą taki sam efekt.

OddEven

Gdy przypiszesz szablonowi ten typ, możesz wstawić dwa subszablony parzysty-nieparzysty: <patTemplate:sub>. Subszablony są używane naprzemiennie, gdy szablon jest powtarzany (np. jaśniejszy i ciemniejszy wiersz tabeli).

Condition

Przypisując szablonowi ten typ, możesz włączać tyle subszablonów, ile zechcesz. Wyświetlenie szablonu w tym przypadku zależy od wystąpienia określonego warunku. Musisz przypisać jedną zmienną, która będzie porównywana ze wszystkimi subszablonami warunkowymi. Są dwa specjalne warunki:

  • default (domyślny, podobnie jak default w przypadku instrukcji switch w języku PHP) oraz
  • empty (pusty), który zostanie wybrany, gdy nie zostanie określony żaden warunek.
SimpleCondition

W typie SimpleCondition możesz zdefiniować kilka wymaganych warunków. SimpleCondition nie zawiera żadnych subszablonów. Szablon będzie widoczny tylko wtedy, gdy spełnione zostaną wszystkie zmiennee warunkowe. Uwaga: aby zdefiniować zmienne, musisz użyć atrybutu requiredvars. Zmienne oddzielasz przecinkami.

Przyjrzyjmy się dokładniej każdemu z tych typów, z wyjątkiem typu Standard, którego dwa przykłady już widzieliśmy.

OddEven

Chcesz tabelę z wierszami w dwu alternatywnych kolorach? W patTemplate osiągasz ten efekt bardzo łatwo, bez skomplikowanego kodu, korzystając z szablonu typu OddEven!

 
<patTemplate:tmpl name="body"> 
  <html> 
   <head> 
     <title>Alternatywne kolory</title> 
   </head> 
   <body> 
      <table> 
        <patTemplate:tmpl name="listaimion" type="OddEven"> 
        <patTemplate:sub condition="odd"> 
        <tr> 
           <td bgcolor="#EBEEF3">{IMIE}</td> 
        </tr> 
        </patTemplate:sub> 
        <patTemplate:sub condition="even"> 
        <tr> 
           <td bgcolor="#FFF2CC">{IMIE}</td> 
        </tr> 
        </patTemplate:sub> 
        </patTemplate:tmpl> 
      </table> 
   </body> 
  </html> 
</patTemplate:tmpl>

Szablon jest całkiem prosty. Mamy tutaj zwykły znacznik patTemplate, z tym że zawiera on atrybut przypisujący typ - OddEven. Wewnątrz znacznika są dwa subszablony - alternatywne. Zapewne zauważyłeś, że jeden z nich ma warunek "Odd" (nieparzysty), a drugi "Even" (parzysty).

Oto kod PHP przetwarzający ten szablon:

<?php 
  // Dolacz plik patTemplate
     include("includes/patTemplate.php"); 
  // Zanicjuj klase patTemplate i utworz nowy obiekt 
     $tmpl = new patTemplate(); 
  // Oznacz katalog, w ktorym umieszczono pliki szablonu. 
     $tmpl->setBasedir("templates"); 
  // Wybierz plik szablonu, ktory ma byc przetwarzany. 
     $tmpl->readTemplatesFromFile("przyklad3.tmpl.html"); 
  // Utworz tablice z imionami
     $imiona = array("IMIE" => array("Piotr", "Jacek", "Robert", 
                    "Maciek", "Anna", "Karolina")); 
  // Dodaj tablice 
     $tmpl->addVars("listaimion", $imiona); 
     $tmpl->parseTemplate("listaimion"); 
  // Przetworz i wypisz szablon
     $tmpl->displayParsedTemplate("body"); 
?>

Objaśnienia wymaga tutaj konstrukcja tablicy: "IMIE" => array() oraz funkcja addVars().

Zastosowana została tutaj tablica wielowymiarowa. Tablica ta przypisuje do zmiennych indeksy (klucze). Gdybym chciał użyć innych zmiennych, mógłbym zapisać to w następujący sposób:

<?php 
array("IMIE" => array("Piotr", "Jacek", "Robert", "Maciek",
                      "Anna", "Karolina"),
      "INNEZMIENNE" => array("wartosc1", "wartosc2"));

Funkcja AddVars () jest tablicą jednowymiarową z wieloma zmiennymi.

Typ Condition

Typ Condition działa na takiej samej zasadzie, jak instrykcja switch w PHP. Wywołanie subszablonu jest zalezne od wystąpienia określonego warunku wymienionego w szablonie warunku conditionvar. Tutaj jest przykład szablonu:

 
<?php 
<patTemplate:tmpl name="body"> 
  <html> 
    <head> 
      <title>Warunkowe odwiedzanie - odwiedziny</title> 
    </head> 
    <body> 
      <form action="przyklad4.php"> 
        <select name="imie"> 
           <option value="Karol" SELECTED>Karol</option> 
           <option value="Anna">Anna</option> 
           <option value="Henryk">Henryk</option> 
        </select> 
        <input type="submit"> 
      </form> 
      <patTemplate:tmpl name="pozdrowienie" type="condition" conditionvar="IMIE"> 
      <patTemplate:sub condition="Anna"> 
        Witam pana kierownika Karola. Co slychac? 
      </patTemplate:sub> 
      <patTemplate:sub condition="Karol"> 
        Witaj Anno! Prosze natychmiast wytrzec podloge! 
      </patTemplate:sub> 
      <patTemplate:sub condition="default"> 
        Witaj nam, gosciu serdeczny! Jak masz na imie? 
      </patTemplate:sub> 
      <patTemplate:sub condition="empty"> 
        Nie widze nikogo! Gdzie jestescie? 
      </patTemplate:sub> 
      </patTemplate:tmpl> 
    </body> 
  </html> 
</patTemplate:tmpl>

Jak widzisz, to rzeczywiście łatwe. Możesz tworzyć dowolną ilość opcji dla conditionvar dzięki podszablonom. Jeśli warunek zgadza się z conditionvar, zawartość szablonu zostanie wyświetlona. Tutaj jest kod PHP do tego przykładu:

<?php 
   // Dolacz plik patTemplate
      include("includes/patTemplate.php"); 
   // Zanicjuj klase patTemplate i utworz nowy obiekt 
      $tmpl = new patTemplate(); 
   // Oznacz katalog, w ktorym umieszczono pliki szablonu.
      $tmpl->setBasedir("templates");
   // Wybierz plik szablonu, ktory ma byc przetwarzany. 
      $tmpl->readTemplatesFromFile("przyklad4.tmpl.html"); 
   //Dodaj warunek (zmienna warunkowa) wybrany z listy rozwijanej
      $tmpl->addVar("pozdrowienie", "IMIE", $_GET['imie']); 
      $tmpl->parseTemplate("pozdrowienie"); 
   // Przetworz i wypisz szablon
      $tmpl->displayParsedTemplate("body"); 
?>

Zapewne rozumiesz, co robi powyższy kod PHP. Linia addVar() dodaje warunek, przesyłając metodą $_GET wybrane z formularza imię. W zależności od wybranego imienia, wyświetlany jest odpowiedni subszablon. Zanim zostanie wybrane jakiekolwiek imię, wyświetlany jest subszablon domyślny. Jeśli nie zostanie wybrane żadne imię, zostanie wyświetlony subszablon empty.

Typ SimpleCondition

Gdy korzystasz z typu SimpleCondition, definiujesz wykaz zmiennych (przypisujesz je za pomocą atrybutu requiredvars, wymaganych, aby szablon był widoczny.

Tutaj jest przykład szablonu, w którym wymagana jest zmienna IMIE.

 
<patTemplate:tmpl name="body"> 
   <html>
      <head>
         <title>SimpleCondition</title>
      </head>
      <body>
         <patTemplate:tmpl name="zmiennazaznaczona" 
                           type="SimpleCondition" requiredvars="IMIE">
            <p>Jest mi milo powiadomic, ze zmiennej "IMIE" 
            zostala nadana wartosc "{IMIE}".</p>
         </patTemplate:tmpl>
      </body>
   </html>
</patTemplate:tmpl>

Zmienną warunkową określasz za pomocą requiredvars.

Jeśli zmienna IMIE nie zostanie określona, to komunikat wewnątrz szablonu SimpleCondition nie będzie widoczny. Poniżej jest kod PHP:

<?php
   // Dolacz plik patTemplate
      include("includes/patTemplate.php"); 
  // Zanicjuj klase patTemplate i utworz nowy obiekt 
      $tmpl = new patTemplate(); 
  // Oznacz katalog, w ktorym umieszczono pliki szablonu. 
      $tmpl->setBasedir("templates"); 
  // Wybierz plik szablonu, ktory ma byc przetwarzany. 
      $tmpl->readTemplatesFromFile("przyklad5.tmpl.html"); 
  // Dodaj do szablonu wymagane zmienne 
      $tmpl->addVar("zmiennazaznaczona", "IMIE", "Patryk"); 
      $tmpl->parseTemplate("zmiennazaznaczona"); 
  // Przetworz i wypisz szablon
      $tmpl->displayParsedTemplate("body"); 
?>

Możesz spróbować wstawić znak komentarza przy linii addVar (), aby przekonać się, że komunikat nie zostanie wyświetlony.

Widoczność szablonu

Przyszedł czas, aby pokazać, jak uczynić szablon widocznym. Do znacznika szablonu trzeba dodać atrybut visbility. Atrybut visbility ma dwie opcje:

  • show - opcja domyślna, szablon będzie widoczny lub
  • hidden - jeśli zadeklarujesz, szablon będzie niewidoczny.

Poniżej jest przykład szablonu niewidocznego:

 
<?php 
<patTemplate:tmpl name="body"> 
   <html> 
      <head> 
         <title>Niewidoczny szablon</title> 
      </head> 
      <body> 
         <patTemplate:tmpl name="zawartosc" visibility="hidden"> 
            Ten tekst nie bedzie widoczny 
         </patTemplate:tmpl> 
      </body>
   </html>
</patTemplate:tmpl>

Ta właściwość nie byłaby oczywiście zbytnio użyteczna, gdybyś nie mógł jej ustawić w swoim projekcie. Z pomocą przychodzi funkcja setAttribute ().

Spójrzmy na kod PHP:

<?php 
  // Dolacz plik patTemplate
     include("includes/patTemplate.php"); 
  // Zanicjuj klase patTemplate i utworz nowy obiekt 
     $tmpl = new patTemplate(); 
  // Oznacz katalog, w ktorym umieszczono pliki szablonu. 
     $tmpl->setBasedir("templates"); 
  // Wybierz plik szablonu, ktory ma byc przetwarzany.  
     $tmpl->readTemplatesFromFile("przyklad9.tmpl.html"); 
  // Uczyn zawartosc - "zawartosc"  - szablonu widoczna 
     $tmpl->setAttribute("zawartosc", "visibility", "show"); 
  // Przetworz i wypisz szablon 
     $tmpl->displayParsedTemplate("body"); 
?>

Możesz spróbować wstawić znak komentarza przy linii setAttribute i zobaczyć, co się stanie.

Ta właściwość może być wykorzystana np. do ukrywania bądź wyświetlania komunikatów błędów.

Linkowanie szablonów

System patTemplate posiada wiele innych użyteczych właściwości. Jedną z nich jest zdolność linkowania - łączenia szablonów. Tutaj masz przykład podlinkowani szablonu:

 
<patTemplate:tmpl name="body"> 
  <html>
     <head>
        <title>Linkowanie szablonów</title>
     </head>
     <body>
        <patTemplate:link src="zawartosc" />
     </body>
  </html> 
</patTemplate:tmpl>
 
<patTemplate:tmpl name="zawartosc"> 
   <p>To jest zawartość. 
     Bedzie wyświetlana w szablonie granicach elementu  body. <br /> 
     Możesz swobodnie używać wewnatrz szablonów zmiennych. 
     W ten sposob:<br /><br /> 
     Moja nazwa to  {NAME}.
</patTemplate:tmpl>

Link w szablonie body jest odnośnikiem do szablonu "zawartosc", powodującym dołączenie go do szablonu body. Proste? Właśnie linkowanie - łączenie szablonów czyni tworzenie o wiele prostszym dużych serwisów.

Poniżej jest kod PHP, który zastosowałem:

<?php 
  // Dolacz plik patTemplate
     include("includes/patTemplate.php"); 
  // Zanicjuj klase patTemplate i utworz nowy obiekt  
     $tmpl = new patTemplate(); 
  // Oznacz katalog, w ktorym umieszczono pliki szablonu. 
     $tmpl->setBasedir("templates"); 
  // Wybierz plik szablonu, ktory ma byc przetwarzany. 
     $tmpl->readTemplatesFromFile("przyklad6.tmpl.html");
  // Dodaj do szablonu zmiena IMIE 
     $tmpl->addVar("zawartosc", "IMIE", "Maria"); 
  // Przetworz i wypisz szablon 
     $tmpl->displayParsedTemplate("body"); 
?>

Poniżej przyklad podlinkowania zewnętrznego pliku szablonu. W atrybucie src został wskazany zewnętrzny plik szablonu :

 
<patTemplate:tmpl name="body"> 
   <html>
      <head> 
         <title>Laczenie szablonow</title>
      </head>
      <body>
         <patTemplate:tmpl name="zawartosc" src="przyklad7zawartosc.tmpl.html" />
      </body>
   </html>
</patTemplate:tmpl>

Kod PHP, który możesz zastosować do tego szablonu, znajduje się poniżej:

 
<?php 
  // Dolacz plik patTemplate
     include("includes/patTemplate.php"); 
  // Zanicjuj klase patTemplate i utworz nowy obiekt 
     $tmpl = new patTemplate(); 
  // Oznacz katalog, w ktorym umieszczono pliki szablonu. 
     $tmpl->setBasedir("templates"); 
  // Wybierz plik szablonu, ktory ma byc przetwarzany.
     $tmpl->readTemplatesFromFile("przyklad7.tmpl.html"); 
  // Dodaj do szablonu zmienne IMIE
     $tmpl->addVar("content", "IMIE", "Maria"); 
  // Przetworz i wypisz szablon  
     $tmpl->displayParsedTemplate("body"); 
?>

Zwykle umieszczam wszystkie swoje szablony w trzech plikach: header, content i footer (nagłówek, zawartość i stopka). To upraszcza pracę. Jeśli chcę zmienić coś w szablonach nagłówka, to zmieniam tylko w jednym pliku, zamiast wprowadzania zmian w kilku plikach pojedynczych szablonów.

Zmienne globalne

Dotychczas analizowaliśmy patTemplate używające tylko zmiennych lokalnych. W patTemplate możemy stosowac zmienne o zasięgu:

  • lokalnym i
  • globalnym.

Poniżej przykład zastosowania zmiennej globalnej:

 
 
<patTemplate:tmpl name="body">
   <html>
      <head>
         <title>Zasieg zmiennej</title>
      </head>
      <body>
         <p>Ten link prowadzi do grafiki <a href="{PLIKOBRAZU}">{PLIKOBRAZU}</a>
            <br /><br />
            <patTemplate:tmpl name="new">
         <p>Uzyto go takze w tym szablonie - zobacz: {PLIKOBRAZU}
            </patTemplate:tmpl>
      </body>
   </html>
   </patTemplate:tmpl>

I tutaj kod PHP:

 
<?php 
  // Dolacz plik patTemplate
     include("includes/patTemplate.php"); 
  // Zanicjuj klase patTemplate i utworz nowy obiekt 
     $tmpl = new patTemplate(); 
  // Oznacz katalog, w ktorym umieszczono pliki szablonu. 
     $tmpl->setBasedir("templates"); 
  // Wybierz plik szablonu, ktory ma byc przetwarzany. 
     $tmpl->readTemplatesFromFile("przyklad8.tmpl.html"); 
  // Dodaj do szablonu zmienna globalna
     $tmpl->addGlobalVar("PLIKOBRAZU", "imitacja-obraz.jpg"); 
  // Przetworz i wypisz szablon 
     $tmpl->displayParsedTemplate("body"); 
?>

Gdy użyjesz funkcji addGlobalVar(), dodajesz wartość tej zmiennej także we wszystkich dołączanych plikach subszablonów.

Zakończenie

Znasz już wystarczająco dobrze podstawy patTemplate, aby rozpocząć tworzenie własnego szablonu. W artykule rozpatrzyliśmy:

  • podstawy przetwarzania patTemplate w PHP
  • iterację (pętlę w szablonie)
  • cztery różne typy szablonów (standard, oddeven, condition, simplecondition)
  • widzialność szablonu
  • łączenie szablonów (oba sposoby: wewnętrznych i zewnętrznych)
  • zmienne globalne i lokalne

Jeżeli chcesz dowiedzieć sie więcej o patTemplate, skorzystaj z dokumentacji online.

[Jeżeli chcesz zobaczyć patTemplate w działaniu, zobacz mój aktualny projekt, Radnews - uwaga tłumaca: aktualnie niedostępny].

Oczywiście, zawsze możesz również posłać swoje dowolne pytania i komentarze do tego artykułu na forum devArticles.

Zgłoś uwagi, podyskutuj

Jeśli chcesz skomentować ten artykuł, zgłosić uwagi, pytania, sugestie, przejdź na nasze FORUM.JOOMLA.PL - Wątek dyskusyjny o tym artykule

Tłum. Stefan Wajda (zwiastun)
Przedruk tylko za zgodą autora tłumaczenia

Zmieniony ( 07.05.2009. )