login  Naam:   Wachtwoord: 
Registreer je!
 Forum

Template php variable maken

Offline jolly9 - 22/09/2006 10:42 (laatste wijziging 22/09/2006 11:35)
Avatar van jolly9Nieuw lid is het mogelijk om in een bestaande template:
in die file nog php code uit te voeren?

php code - Bekijk de code zonder highlighting - Klap code in 
  1. <?
  2.  $temp = template.inc   
  3.  
  4.     $t=new Template;
  5.      $t->set_file("ctlr","/language.php"); // deze regel is toegevoegd en is bedoelt om alle tekst die van een bepaalde taal afhankelijk zijn te vervangen.
  6.      $t->set_file("ctlr","$temp");
  7.      $t->set_block("ctlr","desc","hd");
  8.  
  9.                   $t->set_var(array(        
  10.                          "text1"=>$text1,
  11.                  "text2"=>$text2,
  12.                       "text3"=>$text3,
  13.                           ));
  14.               $t->parse("hd","desc",true);
  15.          }
  16.      }
  17. ?>


i vroeg me dus af of ik op een simple manier een extra file in de template kan toevoegen
zonder alles opnieuw uit te schrijven onder array "xxx" => yyy, etc etc.


en zo ja hoe doe ik dat?
groetjes

7 antwoorden

Gesponsorde links
Offline Wijnand - 22/09/2006 11:35 (laatste wijziging 22/09/2006 11:35)
Avatar van Wijnand Moderator uhh, sommige template engines kunnen het wel, sommige niet.

Welke gebruik jij?

Verder kun je om de code op dit forum even [ code ] en [ /code ] zetten (nu heb ik het gedaan voor je), dan is het duidelijker leven.
Offline jolly9 - 22/09/2006 11:44
Avatar van jolly9 Nieuw lid ik heb geen idee...
waar kan ik dat zien....

ik heb algekeken naar smarty maar die staan volgens mij niet
op de server... althans... met >locate smarty ... krijg ik nix.
Offline Wijnand - 22/09/2006 11:54
Avatar van Wijnand Moderator Er zijn hier 3 tutorials (kopje PHP) die over templates gaan. Lees die eerst maar is door. Dan heb je een beetje een "template-basis". Van daaruit kun je verder gaan kijken (en omschrijven )
Offline jolly9 - 22/09/2006 12:29
Avatar van jolly9 Nieuw lid ik heb ze door gelezen maar het lijkt er op dat ik geen van de drie gebruik.

ik heb namelijk een file die ik include in het bestaande bestand
namelijk:
php code - Bekijk de code zonder highlighting - Klap code in 
  1. <?php 
  2.  
  3. class Template {
  4.   var $classname = "Template";
  5.  
  6.   /* if set, echo assignments */
  7.   var $debug     = false;
  8.  
  9.   /* $file[handle] = "filename"; */
  10.   var $file  = array();
  11.  
  12.   /* relative filenames are relative to this pathname */
  13.   var $root   = "";
  14.  
  15.   /* $varkeys[key] = "key"; $varvals[key] = "value"; */
  16.   var $varkeys = array();
  17.   var $varvals = array();
  18.  
  19.   /* "remove"  => remove undefined variables
  20.    * "comment" => replace undefined variables with comments
  21.    * "keep"    => keep undefined variables
  22.    */
  23.   var $unknowns = "remove";
  24.  
  25.   /* "yes" => halt, "report" => report error, continue, "no" => ignore error quietly */
  26.   var $halt_on_error  = "yes";
  27.  
  28.   /* last error message is retained here */
  29.   var $last_error     = "";
  30.  
  31.  
  32.   /***************************************************************************/
  33.   /* public: Constructor.
  34.    * root:     template directory.
  35.    * unknowns: how to handle unknown variables.
  36.    */
  37.   function Template($root = ".", $unknowns = "remove") {
  38.     $this->set_root($root);
  39.     $this->set_unknowns($unknowns);
  40.   }
  41.  
  42.   /* public: setroot(pathname $root)
  43.    * root:   new template directory.
  44.    */
  45.   function set_root($root) {
  46.     if (!is_dir($root)) {
  47.       $this->halt("set_root: $root is not a directory.");
  48.       return false;
  49.     }
  50.  
  51.     $this->root = $root;
  52.     return true;
  53.   }
  54.  
  55.   /* public: set_unknowns(enum $unknowns)
  56.    * unknowns: "remove", "comment", "keep"
  57.    *
  58.    */
  59.   function set_unknowns($unknowns = "keep") {
  60.     $this->unknowns = $unknowns;
  61.   }
  62.  
  63.   /* public: set_file(array $filelist)
  64.    * filelist: array of handle, filename pairs.
  65.    *
  66.    * public: set_file(string $handle, string $filename)
  67.    * handle: handle for a filename,
  68.    * filename: name of template file
  69.    */
  70.   function set_file($handle, $filename = "") {
  71.     if (!is_array($handle)) {
  72.       if ($filename == "") {
  73.         $this->halt("set_file: For handle $handle filename is empty.");
  74.         return false;
  75.       }
  76.       $this->file[$handle] = $this->filename($filename);
  77.     } else {
  78.       reset($handle);
  79.       while(list($h, $f) = each($handle)) {
  80.         $this->file[$h] = $this->filename($f);
  81.       }
  82.     }
  83.   }
  84.  
  85.   /* public: set_block(string $parent, string $handle, string $name = "")
  86.    * extract the template $handle from $parent,
  87.    * place variable {$name} instead.
  88.    */
  89.   function set_block($parent, $handle, $name = "") {
  90.     if (!$this->loadfile($parent)) {
  91.       $this->halt("subst: unable to load $parent.");
  92.       return false;
  93.     }
  94.     if ($name == "")
  95.       $name = $handle;
  96.  
  97.     $str = $this->get_var($parent);
  98.     $reg = "/<!--\s+BEGIN $handle\s+-->(.*)\n\s*<!--\s+END $handle\s+-->/sm";
  99.     preg_match_all($reg, $str, $m);
  100.     $str = preg_replace($reg, "{" . "$name}", $str);
  101.     $this->set_var($handle, $m[1][0]);
  102.     $this->set_var($parent, $str);
  103.   }
  104.  
  105.   /* public: set_var(array $values)
  106.    * values: array of variable name, value pairs.
  107.    *
  108.    * public: set_var(string $varname, string $value)
  109.    * varname: name of a variable that is to be defined
  110.    * value:   value of that variable
  111.    */
  112.   function set_var($varname, $value = "") {
  113.     if (!is_array($varname)) {
  114.       if (!empty($varname))
  115.         if ($this->debug) print "scalar: set *$varname* to *$value*<br>\n";
  116.         $this->varkeys[$varname] = "/".$this->varname($varname)."/";
  117.         $this->varvals[$varname] = $value;
  118.     } else {
  119.       reset($varname);
  120.       while(list($k, $v) = each($varname)) {
  121.         if (!empty($k))
  122.           if ($this->debug) print "array: set *$k* to *$v*<br>\n";
  123.           $this->varkeys[$k] = "/".$this->varname($k)."/";
  124.           $this->varvals[$k] = $v;
  125.       }
  126.     }
  127.   }
  128.  
  129.   /* public: subst(string $handle)
  130.    * handle: handle of template where variables are to be substituted.
  131.    */
  132.   function subst($handle) {
  133.     if (!$this->loadfile($handle)) {
  134.       $this->halt("subst: unable to load $handle.");
  135.       return false;
  136.     }
  137.  
  138.     $str = $this->get_var($handle);
  139.     $str = @preg_replace($this->varkeys, $this->varvals, $str);
  140.     return $str;
  141.   }
  142.  
  143.   /* public: psubst(string $handle)
  144.    * handle: handle of template where variables are to be substituted.
  145.    */
  146.   function psubst($handle) {
  147.     print $this->subst($handle);
  148.  
  149.     return false;
  150.   }
  151.  
  152.   /* public: parse(string $target, string $handle, boolean append)
  153.    * public: parse(string $target, array  $handle, boolean append)
  154.    * target: handle of variable to generate
  155.    * handle: handle of template to substitute
  156.    * append: append to target handle
  157.    */
  158.   function parse($target, $handle, $append = false) {
  159.     if (!is_array($handle)) {
  160.       $str = $this->subst($handle);
  161.       if ($append) {
  162.         $this->set_var($target, $this->get_var($target) . $str);
  163.       } else {
  164.         $this->set_var($target, $str);
  165.       }
  166.     } else {
  167.       reset($handle);
  168.       while(list($i, $h) = each($handle)) {
  169.         $str = $this->subst($h);
  170.         $this->set_var($target, $str);
  171.       }
  172.     }
  173.  
  174.     return $str;
  175.   }
  176.  
  177.   function pparse($target, $handle, $append = false) {
  178.     print $this->parse($target, $handle, $append);
  179.     return false;
  180.   }
  181.  
  182.   /* public: get_vars()
  183.    */
  184.   function get_vars() {
  185.     reset($this->varkeys);
  186.     while(list($k, $v) = each($this->varkeys)) {
  187.       $result[$k] = $this->varvals[$k];
  188.     }
  189.  
  190.     return $result;
  191.   }
  192.  
  193.   /* public: get_var(string varname)
  194.    * varname: name of variable.
  195.    *
  196.    * public: get_var(array varname)
  197.    * varname: array of variable names
  198.    */
  199.   function get_var($varname) {
  200.     if (!is_array($varname)) {
  201.       return $this->varvals[$varname];
  202.     } else {
  203.       reset($varname);
  204.       while(list($k, $v) = each($varname)) {
  205.         $result[$k] = $this->varvals[$k];
  206.       }
  207.  
  208.       return $result;
  209.     }
  210.   }
  211.  
  212.   /* public: get_undefined($handle)
  213.    * handle: handle of a template.
  214.    */
  215.   function get_undefined($handle) {
  216.     if (!$this->loadfile($handle)) {
  217.       $this->halt("get_undefined: unable to load $handle.");
  218.       return false;
  219.     }
  220.  
  221.     preg_match_all("/\{([^}]+)\}/", $this->get_var($handle), $m);
  222.     $m = $m[1];
  223.     if (!is_array($m))
  224.       return false;
  225.  
  226.     reset($m);
  227.     while(list($k, $v) = each($m)) {
  228.       if (!isset($this->varkeys[$v]))
  229.         $result[$v] = $v;
  230.     }
  231.  
  232.     if (count($result))
  233.       return $result;
  234.     else
  235.       return false;
  236.   }
  237.  
  238.   /* public: finish(string $str)
  239.    * str: string to finish.
  240.    */
  241.   function finish($str) {
  242.     switch ($this->unknowns) {
  243.       case "keep":
  244.       break;
  245.  
  246.       case "remove":
  247.         $str = preg_replace('/{[^ \t\r\n}]+}/', "", $str);
  248.       break;
  249.  
  250.       case "comment":
  251.         $str = preg_replace('/{([^ \t\r\n}]+)}/', "<!-- Template $handle: Variable \\1 undefined -->", $str);
  252.       break;
  253.     }
  254.  
  255.     return $str;
  256.   }
  257.  
  258.   /* public: p(string $varname)
  259.    * varname: name of variable to print.
  260.    */
  261.   function p($varname) {
  262.     print $this->finish($this->get_var($varname));
  263.   }
  264.  
  265.   function get($varname) {
  266.     return $this->finish($this->get_var($varname));
  267.   }
  268.  
  269.   /***************************************************************************/
  270.   /* private: filename($filename)
  271.    * filename: name to be completed.
  272.    */
  273.   function filename($filename) {
  274.     if (substr($filename, 0, 1) != "/") {
  275.       $filename = $this->root."/".$filename;
  276.     }
  277.  
  278.     if (!file_exists($filename))
  279.       $this->halt("filename: file $filename does not exist.");
  280.  
  281.     return $filename;
  282.   }
  283.  
  284.   /* private: varname($varname)
  285.    * varname: name of a replacement variable to be protected.
  286.    */
  287.   function varname($varname) {
  288.     return preg_quote("{".$varname."}");
  289.   }
  290.  
  291.   /* private: loadfile(string $handle)
  292.    * handle:  load file defined by handle, if it is not loaded yet.
  293.    */
  294.   function loadfile($handle) {
  295.     if (isset($this->varkeys[$handle]) and !empty($this->varvals[$handle]))
  296.       return true;
  297.  
  298.     if (!isset($this->file[$handle])) {
  299.       $this->halt("loadfile: $handle is not a valid handle.");
  300.       return false;
  301.     }
  302.     $filename = $this->file[$handle];
  303.  
  304.     $str = implode("", @file($filename));
  305.     if (empty($str)) {
  306.       $this->halt("loadfile: While loading $handle, $filename does not exist or is empty.");
  307.       return false;
  308.     }
  309.  
  310.     $this->set_var($handle, $str);
  311.  
  312.     return true;
  313.   }
  314.  
  315.   /***************************************************************************/
  316.   /* public: halt(string $msg)
  317.    * msg:    error message to show.
  318.    */
  319.   function halt($msg) {
  320.     $this->last_error = $msg;
  321.  
  322.     if ($this->halt_on_error != "no")
  323.       $this->haltmsg($msg);
  324.  
  325.     if ($this->halt_on_error == "yes")
  326.       die("<b>Halted.</b>");
  327.  
  328.     return false;
  329.   }
  330.  
  331.   /* public, override: haltmsg($msg)
  332.    * msg: error message to show.
  333.    */
  334.   function haltmsg($msg) {
  335.     printf("<b>Template Error:</b> %s<br>\n", $msg);
  336.   }
  337. }
  338.  
  339. ?>


het enige wat ik wil weten of er mogelijk is m.b.v. 2 verschillende language files: Language_EN.php / Language_FR.php te includen waar door de taal wordt gewijzigd.
Offline Wijnand - 22/09/2006 12:34 (laatste wijziging 22/09/2006 12:39)
Avatar van Wijnand Moderator Ja dat is mogelijk 

edit:
Ik zal eens kijken, maar wat wil je in het engels/nederlands. Want ik denk dat je dus een "nieuwe" opzet moet gaan doen.

Dus kan je iets meer info geven over die talen?
Offline jolly9 - 22/09/2006 12:47 (laatste wijziging 22/09/2006 12:54)
Avatar van jolly9 Nieuw lid ff een test pagina wat ik dus nu probeer is dit:

php code - Bekijk de code zonder highlighting - Klap code in 
  1. <?php
  2.  
  3. include("temp_inc.php"); // dat is de file die ik hierboven heb gepost.
  4.  
  5. $text1="HALLOWWW";  
  6.  
  7. $temp = "template.inc";
  8. $lang = "lang_en.txt";
  9. {
  10. $t=new Template;
  11. $t->set_file("ctlr","$lang");
  12. $t->set_file("ctlr","$temp");
  13. $t->set_block("ctlr","desc","hd");
  14.  
  15. require(lang_en.txt);
  16. 	$t->set_var(array(
  17. //include("lang_en.txt");	
  18. 			"text1"=>$text1,
  19. 			"text2"=>$text2,
  20. 			"text3"=>$text3
  21. 	));
  22. //$t->set_var(array("dycity"=>$loc));
  23. $t->parse("hd","desc",true);
  24. $t->parse("opt","ctlr");
  25. $t->p("opt");
  26. }
  27. ?>


dit is de code die bijv. de lang_en.txt bevat bijv.
php code - Bekijk de code zonder highlighting - Klap code in 
  1. $t->set_var(array(
  2. 			"lang1"=>"EN 1",
  3. 			"lang2"=>"EN 2",
  4. 			"lang3"=>EN 3
  5. 	));


maar hiermee is het mij dus nog niet gelukt... ik krijg wel "HALLOWWW" te zien maar nog niet de EN 1,2 of 3 ....

...........................edit...........................:::

dit kan overigens wel, ben ik inmiddels achter, maar een combinatie
om 2 templates te include is me nog niet gelukt... dus
graag jou expertise hierover...

php code - Bekijk de code zonder highlighting - Klap code in 
  1. <?php
  2.  include("temp_inc.php"); 
  3.  $text1="HALLOWWW";  
  4.  
  5. $temp = "template.inc";
  6. $lang = "lang_en.php";
  7. {
  8. $t=new Template;
  9. $t->set_file("ctlr","$lang");
  10. $t->set_file("ctlr","$temp");
  11. $t->set_block("ctlr","desc","hd");
  12.  
  13. include("lang_en.php");	
  14. //require(lang_en.txt);
  15. /*
  16. 	$t->set_var(array(
  17. include("lang_en.php");	
  18. 			"text1"=>$text1,
  19. 			"text2"=>$text2,
  20. 			"text3"=>$text3
  21. 	));
  22. */	
  23. //$t->set_var(array("dycity"=>$loc));
  24. $t->parse("hd","desc",true);
  25. $t->parse("opt","ctlr");
  26. $t->p("opt");
  27. }
  28. ?>
Offline Thomas - 22/09/2006 15:13
Avatar van Thomas Moderator Ik zou voor elke taal een folder met templates maken:
templates/en/...
templates/nl/...
die dus verder dezelfde templates hebben, maar inhoudelijk van taal verschillen.
Op grond van de geselecteerde taal lees je uit een van de twee folders. Hier kom je bijna niet omheen als je meerdere talen wilt gebruiken.
Gesponsorde links
Dit onderwerp is gesloten.
Actieve forumberichten
© 2002-2024 Sitemasters.be - Regels - Laadtijd: 0.225s