Ankündigung

Einklappen
Keine Ankündigung bisher.

[Erledigt] Variablen in einem Template ersetzen

Einklappen
X
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • [Erledigt] Variablen in einem Template ersetzen

    Guten Tag,

    Ich habe ein kleines Problem beim ersetzen von Template Variablen.
    Template:
    Code:
    Test
    Test
    {multiply name="personen"}
    {$personen.name} {$personen.vorname} {multiply name="hobbys"}
    {$hobbys.name}
    {/multiply}
    {/multiply}
    Im PHP Code weiße ich folgende Werte zu:
    PHP-Code:
    $multiArray = array(array("name"=>"Mueller","vorname"=>"Karl","hobbys"=>array(array("name"=>"Fußball"))));
    $template->assign("personen",$multiArray); 
    In meiner Template Klasse wird das ganze nun in $multiArrays abgespeichert.
    Einfache {multiply} ersetze ich mit folgendem Code:
    PHP-Code:
    private function replaceMultiArrays() {
            foreach(
    $this->multiArrays as $key => $value) {
                
    $pattern '/\{multiply\sname=[\"\']'.$key.'[\"\']\}(.*)\{\/multiply}/isUe';
                if(
    preg_match($pattern,$this->template,$subpattern)) {
                    
    $out="";
                    foreach(
    $value as $valKey => $valValue) {
                            
    $output=$subpattern[1];
                            foreach(
    $valValue as $valvalKey => $valvalValue) {
                                
    $output str_replace($this->leftDelimiter.$key.'.'.$valvalKey.$this->rightDelimiter,$valvalValue,$output);
                            }
                            
    $out .= $output;
                    }
                    
    $this->template str_replace($subpattern[0],$out,$this->template);
                }
            }
            
    $pattern '/\{multiply\sname=[\"\'](.*)[\"\']\}(.*)\{\/multiply}/isUe';
            
    $this->template preg_replace($pattern,"",$this->template);
        } 
    Dies klappt aber nun bei mehreren verschachtelten {multiply} nicht, da es nicht bis zum ende durchgeht.

    Um alle benötigten Informationen zu erhalten habe ich folgendes geschrieben:
    PHP-Code:
    private function replaceMultiArrays2() {
            
    $pattern_begin '/\{multiply\sname\=[\"\'](.*)[\"\']\}/isU';
            
    $pattern_end '/\{\/multiply\}/isU';
            
    $start=0;
            
    $index=1;
            
    $Begins=array();
            while(
    preg_match($pattern_begin,$this->template,$subpatternPREG_OFFSET_CAPTURE,$start)) {
                
    $start=$subpattern[0][1]+strlen("{multiply name='".$subpattern[1][0]."'}");
                
    array_push($Begins,array("name"=>$subpattern[1][0],
                                         
    "index"=>$index,
                                         
    "pos"=>$subpattern[0][1]));
                
    $index++;
            }
            
    $countBegins count($Begins);
            
    $start=0;
            
    $index=$Begins[count($Begins)-1]['index'];
            
    $Ends=array();
            
    $belegt=array();
            while(
    preg_match($pattern_end,$this->template,$subpatternPREG_OFFSET_CAPTURE,$start)) {
                
    $start=$subpattern[0][1]+strlen("{/multiply}");
                while(
    $Begins[$index-1]['pos']>$subpattern[0][1] AND $index>1) {
                    
    $index--;
                }
                while(
    in_array($index,$belegt)) {
                    
    $index--;
                }
                
    array_push($Ends,array("index"=>$index,
                                       
    "pos"=>$subpattern[0][1]));
                
    array_push($belegt,$index);
                
    $index=$Begins[count($Begins)-1]['index'];
            }
            
    $countEnds count($Ends);
            if(
    $countEnds!=$countBegins) {
                throw new 
    Exception("Fehlermeldung");
            }
            
    usort($Begins,array(&$this,"compareMultiArrayIndex"));
            
    usort($Ends,array(&$this,"compareMultiArrayIndex"));
        } 
    Damit erhalte ich die Information, welche {multiply} ich habe und außerdem weiß ich über den Index, welches {/multiply} zu welchem {multiply name="(.*)"} gehört.
    Später sortiere ich das ganze noch nach dem zugewiesenem Index absteigend, weil ich denke, dass ich so zuerst die inneren ersetze, allerdings komme ich nicht weiter, wie ich meine beiden Funktionen zusammen bekomme.
    Das Ersetzen in der ersten Funktion dürfte erst an einer bestimmten Position starten (kein Problem, Position habe ich), aber nun weiß ich nicht wie ich es machen soll, dass er die Informationen aus dem Personen Array nimmt und darin dann mit den Hobbys weiter macht, eine rekursive Funktion wäre natürlich am besten, sodass ich beliebig viele {multiply} ineinander schachteln kann.

    Tschuldigung für den vielen Text, aber ich hoffe es steigt trotzdem irgendwer durch und kann mir helfen


  • #2
    Hallo KarlEgon,

    auf den ersten Blick würde ich sagen: nimm Smarty, da bist du schneller am Ziel.
    Viele Grüße,
    Dr.E.

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    1. Think about software design before you start to write code!
    2. Discuss and review it together with experts!
    3. Choose good tools (-> Adventure PHP Framework (APF))!
    4. Write clean and reusable software only!
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    Kommentar


    • #3
      Oder sieh dir mal diesen Thread an, wenn du nicht auf Smarty zurückgreifen möchtest.
      MfG, Andy

      Kommentar


      • #4
        Habe mir den Thread durchgelesen, aber das ist nicht so ganz das was ich will.

        Smarty habe ich benutzt, will ich aber nicht mehr.
        Ich will es nämlich ein bisschen modular haben. Im moment definiere ich in den Templates verschiedene Sections(z.B. north, south, center usw.)
        Nun kann ich durch $tpl->addTemplate("templatefile.tpl","center"); beliebig viele Templates zu diesen Sections hinzufügen.
        Diese Möglichkeit habe ich meiner Meinung nach bei Smarty nicht. Und auf <?php echo $this->var ?> will ich nicht umsteigen.

        Diese Möglichkeit will ich schon gerne haben. Habe bis jetzt noch kein TemplateSystem gesehen, wo dies unterstützt wird.

        Kommentar


        • #5
          Hallo KarlEgon,

          Smarty habe ich benutzt, will ich aber nicht mehr.
          Ich will es nämlich ein bisschen modular haben.
          Dann solltest du dir dringend das APF (siehe http://de.adventure-php-framework.or.../047-Templates) ansehen, denn generische Templates in beliebiger Komplexität und Struktur hat IMHO nur dieses.

          Solltest du Fragen dazu haben, kannst du dich vertrauensvoll an mich wenden!
          Viele Grüße,
          Dr.E.

          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
          1. Think about software design before you start to write code!
          2. Discuss and review it together with experts!
          3. Choose good tools (-> Adventure PHP Framework (APF))!
          4. Write clean and reusable software only!
          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

          Kommentar


          • #6
            Mhhh das Ding kann ja schon ganz schön viel, aber ich denke das ist mir zu überladen.

            Im moment sieht meine Template Klasse so aus:
            PHP-Code:
            <?php
            class Template {

                private 
            $templateDir "templates";
                private 
            $mainTemplate "main.tpl";
                private 
            $leftDelimiter '{$';
                private 
            $rightDelimiter '}';
                private 
            $leftComments '\{\*';
                private 
            $rightComments '\*\}';
                private 
            $vars = array ();
                private 
            $arrays = array ();
                private 
            $sections = array();
                private 
            $multiArrays = array();
                private 
            $hideAreas = array();
                private 
            $template;
                private 
            $templatePath;

                public function 
            __construct($templateDir ""$mainTemplate "") {
                    if (!empty (
            $templateDir) && $templateDir != "") {
                        
            $this->templateDir $templateDir;
                    }
                    if (!empty (
            $mainTemplate) && $mainTemplate != "") {
                        
            $this->mainTemplate $mainTemplate;
                    }
                }

                public function 
            setTemplateDir($templateDir) {
                    
            $this->templateDir $templateDir;
                }

                public function 
            setMainTemplate($mainTemplate) {
                    
            $this->mainTemplate $mainTemplate;
                }

                public function 
            setLeftDelimiter($leftDelimiter) {
                    
            $this->leftDelimiter $leftDelimiter;
                }

                public function 
            setRightDelimiter($rightDelimiter) {
                    
            $this->rightDelimiter $rightDelimiter;
                }

                public function 
            assign($key$value) {
                    if (
            is_array($value)) {
                        
            $this->addArray($key$value);
                    } else {
                        
            $this->vars[$key] = $value;
                    }
                }

                private function 
            addArray($key$value) {
                    if(
            $this->isDeepMultiArray($value)) {
                        
            $this->addMultiArray($key,$value);
                    } else {
                        
            $this->arrays[$key] = $value;
                    }
                }

                public function 
            addTemplate($file$section) {
                    if(!@
            is_array($this->sections[$section])) {
                        
            $this->sections[$section]=array();
                    }
                    
            array_push($this->sections[$section],$file);
                }

                private function 
            addMultiArray($key,$value) {
                    
            $this->multiArrays[$key] = $value;
                }

                public function 
            hideArea($key) {
                    
            array_push($this->hideAreas,$key);
                }

                public function 
            display() {
                    
            $this->templatePath $this->templateDir "/" $this->mainTemplate;
                    if (!empty (
            $this->templatePath)) {
                        if (
            $fp fopen($this->templatePath"r")) {
                            
            // Den Inhalt des Templates einlesen
                            
            $this->template fread($fpfilesize($this->templatePath));
                            
            fclose($fp);
                        } else {
                            return 
            false;
                        }
                    }
                    
            $this->replaceIncludes();
                    
            $this->replaceSections();
                    
            $this->replaceIncludes();
                    
            $this->replaceMultiArrays();
                    
            //$this->replaceMultiArrays2();
                    
            $this->replaceValues();
                    
            $this->replaceArrays();
                    
            $this->replaceComments();
                    
            $this->hideAreas();
                    
            $this->removePHP();
                    echo 
            $this->template;
                }

                private function 
            replaceIncludes() {
                    
            $pattern '/\{include\sfile=[\"\'](.*)\.(.*)[\"\']\}/isUe';
                    while (
            preg_match($pattern$this->template)) {
                        
            $this->template preg_replace($pattern"file_get_contents(\$this->templateDir.'/\\1'.'.'.'\\2')"$this->template);
                    }
                }

                private function 
            replaceValues() {
                    foreach (
            $this->vars as $key => $value) {
                        
            $this->template str_replace($this->leftDelimiter $key $this->rightDelimiter$value$this->template);
                    }
                }

                private function 
            replaceArrays() {
                    foreach (
            $this->arrays as $key => $value) {
                        foreach (
            $value as $valKey => $valValue) {
                            
            $pattern '/^(\{multiply\sname=[\"\'](.*)[\"\']\})'.$this->leftDelimiter.$key.'\.'.$valKey.$this->rightDelimiter.'^(\{\/multiply\})/is';
                            if(
            preg_match($pattern,$this->template,$subpattern)) {
                                
            //debugprint($subpattern);
                            
            }
                            
            $this->template str_replace($this->leftDelimiter $key "." $valKey $this->rightDelimiter$valValue$this->template);
                        }
                    }
                }

                private function 
            replaceMultiArrays($sub="",$pos=0) {
                    foreach(
            $this->multiArrays as $key => $value) {
                        if(
            $sub=="") {
                            
            $pattern '/\{multiply\sname=[\"\']'.$key.'[\"\']\}(.*)\{\/multiply}/isUe';
                        } else {
                            
            $pattern '/\{multiply\sname=[\"\']'.$sub.'[\"\']\}(.*)\{\/multiply}/isUe';
                        }
                        if(
            preg_match($pattern,$this->template,$subpattern,null,$pos)) {
                            
            //debugprint($subpattern,false,$sub);
                            
            $out="";
                            
            //ausgabe($sub." ".count($value));
                            
            foreach($value as $valKey => $valValue) {
                                    
            //ausgabe($valKey."---".$valValue);
                                    
            $output=$subpattern[1];
                                    foreach(
            $valValue as $valvalKey => $valvalValue) {
                                        if(!
            is_array($valvalValue)) {
                                            
            $output str_replace($this->leftDelimiter.$key.'.'.$valvalKey.$this->rightDelimiter,$valvalValue,$output);
                                            
            //$output = str_replace($this->leftDelimiter.$key.'.'.$valvalKey.$this->rightDelimiter,$subpattern[1],$output);
                                        
            }
                                    }
                                    
            $out .= $output;
                            }
                            
            //ausgabe(trim(htmlspecialchars($out)));
                            //ausgabe($subpattern[0]);
                            
            $this->template str_replace($subpattern[0],$out,$this->template);
                        }
                    }
                    
            $pattern '/\{multiply\sname=[\"\'](.*)[\"\']\}(.*)\{\/multiply}/isUe';
                    
            $this->template preg_replace($pattern,"",$this->template);
                }

                private function 
            replaceMultiArrays2() {
                    
            $pattern_begin '/\{multiply\sname\=[\"\'](.*)[\"\']\}/isU';
                    
            $pattern_end '/\{\/multiply\}/isU';
                    
            $start=0;
                    
            $index=1;
                    
            $Begins=array();
                    
            $error=false;
                    while(
            preg_match($pattern_begin,$this->template,$subpatternPREG_OFFSET_CAPTURE,$start)) {
                        
            $start=$subpattern[0][1]+strlen("{multiply name='".$subpattern[1][0]."'}");
                        
            array_push($Begins,array("type"=>"begin",
                                                 
            "name"=>$subpattern[1][0],
                                                 
            "index"=>$index,
                                                 
            "pos"=>$subpattern[0][1]));
                        
            $index++;
                    }
                    
            $countBegins count($Begins);
                    
            $start=0;
                    
            $index=$Begins[count($Begins)-1]['index'];
                    
            $Ends=array();
                    
            $belegt=array();
                    while(
            preg_match($pattern_end,$this->template,$subpatternPREG_OFFSET_CAPTURE,$start)) {
                        
            $start=$subpattern[0][1]+strlen("{/multiply}");
                        while(
            $Begins[$index-1]['pos']>$subpattern[0][1] AND $index>1) {
                            
            $index--;
                        }
                        while(
            in_array($index,$belegt)) {
                            
            $index--;
                        }
                        if(
            $index<=0) {
                            
            $error=true;
                        }
                        
            array_push($Ends,array("type"=>"end",
                                               
            "index"=>$index,
                                               
            "pos"=>$subpattern[0][1]));
                        
            array_push($belegt,$index);
                        
            $index=$Begins[count($Begins)-1]['index'];
                    }
                    
            $countEnds count($Ends);
                    if(
            $countEnds!=$countBegins || $error) {
                        throw new 
            Exception("Template Fehlerhaft");
                    }
                    
            usort($Begins,array(&$this,"compareMultiArrayPos"));
                    
            //debugprint($Begins);
                    //usort($Ends,array(&$this,"compareMultiArrayPos"));
                    
            foreach($Begins as $value) {
                        if(
            $value['name']!='infos') {
                            
            $this->replaceMultiArrays4($value['name'],$value['pos']);
                        }
                        
            //ausgabe($value['name']."---".$value['pos']);
                    
            }
                    
            //debugprint($Begins);
                    //debugprint($Ends);
                    
            $All array_merge($Begins,$Ends);
                    
            usort($All,array(&$this,"compareMultiArrayPos"));
                    
            //debugprint($All);
                    //debugprint($this->multiArrays);
                    /*for($i=0;$i<count($All)-1;$i++) {
                        if($All[$i]['type']=='begin' AND $All[$i+1]['type']=='end') {
                            //$this->replaceMultiArrays3($this->multiArrays[$All[$i]['name']],$All[$i]['pos'],$All[$i]['name']);
                        }
                        if($All[$i]['type']=='begin' AND $All[$i+1]['type']=='begin') {
                            $this->replaceMultiArrays3($this->multiArrays[$All[$i]['name']],$All[$i]['pos'],$All[$i+1]['name'],true);
                            $i++;
                        }
                    }*/
                
            }

                private function 
            hideAreas() {
                    foreach(
            $this->hideAreas as $area) {
                        
            $pattern '/\{area\sname=[\"\']'.$area.'[\"\']\}(.*)\{\/area}/isUe';
                        while(
            preg_match($pattern,$this->template)) {
                            
            $this->template preg_replace($pattern,"",$this->template);
                        }
                    }
                    
            $pattern '/\{area\sname=[\"\'](.*)[\"\']\}/isUe';
                    
            $this->template preg_replace($pattern,"",$this->template);
                    
            $pattern '/\{\/area}/isUe';
                    
            $this->template preg_replace($pattern,"",$this->template);
                }

                private function 
            replaceSections() {
                    foreach(
            $this->sections as $key => $value) {
                        
            //ausgabe($key."---".$value);
                        
            $output="";
                        foreach(
            $value as $file) {
                            
            $output .= "{include file='".$file."'}";
                        }
                        
            $pattern "/\{section name=\"$key\"\}/";
                        
            $this->template preg_replace($pattern,$output,$this->template);
                    }
                    
            $pattern '/\{section\sname=[\"\'](.*)[\"\']\}/isUe';
                    while(
            preg_match($pattern,$this->template)) {
                        
            $this->template preg_replace($pattern,"",$this->template);
                    }
                }

                private function 
            replaceComments() {
                    
            $pattern "/".$this->leftComments."(.*)".$this->rightComments."/isUe";
                    while(
            preg_match($pattern,$this->template)) {
                        
            $this->template preg_replace($pattern,"",$this->template);
                    }
                }

                private function 
            removePHP() {
                    
            $pattern '/\<\?[ph]{0,3}(.*)[ph]{0,3}\?\>/isUe';
                    while(
            preg_match($pattern,$this->template)) {
                        
            $this->template preg_replace($pattern,"",$this->template);
                    }
                }

                private function 
            compareMultiArrayIndex($a,$b) {
                    if(
            $a['index']==$b['index']) {
                        return 
            0;
                    }
                    return (
            $a['index']<$b['index']) ? : -1;
                }

                private function 
            compareMultiArrayPos($a,$b) {
                    if(
            $a['pos']==$b['pos']) {
                        return 
            0;
                    }
                    return (
            $a['pos']<$b['pos']) ? -1;
                }

                private function 
            isDeepMultiArray($multiarray$level 2) {  // default is simple multiarray
                
            if (is_array($multiarray)) {  // confirms array
                    
            if ($level == 1) {  // $level reaches 1 after specified # of recursions
                        
            return true;  // returns true to recursive function conditional
                    
            }  // end conditional
                    
            foreach ($multiarray as $array) {  // goes one level deeper into array
                        
            if ($this->isDeepMultiArray($array$level 1)) {  // check subarray
                            
            return true;  // best if $message = true so function returns boolean
                        
            }  // end recursive function
                    
            }  // end loop
                
            } else {  // not an array at specified level
                
            return false;  // is also used recursively so can't change to message
                
            }
            }
            }
            ?>
            Habe viel herumprobiert, deswegen sieht es manchmal vielleicht ein bisschen chaotisch aus. Ich weiß nicht wie ich es realisieren soll, dass alles ersetzt wird so wie ich es brauche.

            Kommentar


            • #7
              Hallo KarlEgon,

              Mhhh das Ding kann ja schon ganz schön viel, aber ich denke das ist mir zu überladen.
              Sorry, aber die Anforderungen, die du stellst, sind nicht durch eine ungenerische Implementierung zu erschlagen.

              Versuch doch bitte - ehe du Resignation zeigst - zu beschreiben, wie deine Applikation aussehen soll und welche Anforderungen umzusetzen sind. Ich bin mir 100%ig sicher, dass es dafür eine elegante und nicht überladene Antwort und Lösung mit dem APF gibt. Die Wette gilt!
              Viele Grüße,
              Dr.E.

              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
              1. Think about software design before you start to write code!
              2. Discuss and review it together with experts!
              3. Choose good tools (-> Adventure PHP Framework (APF))!
              4. Write clean and reusable software only!
              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

              Kommentar


              • #8
                Also
                Ein Beispiel Template:
                Code:
                //main.tpl
                <html>
                <head>
                <title>{$titel}</title>
                </head> <body>
                <div id="header">{$seitentitel}{section name="north"}</div> <div id="left">{section name="west"}</div> <div id="right">{section name="east"}</div> <div id="content"><h1>{$seitentitel}</h1>{section name="center"}</div> <div id="footer">{section name="south"}</div>
                </body>
                </html>
                Ein weiteres Template:
                Code:
                //Navigation.tpl
                <div id="navi">
                {multiply name="navi"} <a href="{$navi.link}">{$navi.name}</a> {/multiply}
                </div>
                Und noch ein Template:
                Code:
                //Status.tpl
                <div id="status">
                Fertigstellungsgrad: {$fertig} %
                </div>
                Im PHP Code:
                PHP-Code:
                $tpl = new Template();
                $tpl->assign("titel","Testseite");
                $tpl->assign("seitentitel","Status");
                $tpl->assign("fertig",20);
                $navi = array();
                for(
                $i=0;$i<6;$i++) {
                array_push($navi,array("link"=>"#","name"=>"Test".$i));
                }
                $tpl->assign("navi",$navi);
                $tpl->addTemplate("Navigation.tpl","west");
                $tpl->addTemplate("Status.tpl","center");
                $tpl->display(); //Main.tpl wird standardmäßig genommen 
                Naja und dann soll er mir daraus halt eine Seite bauen, also zu den verschiedenen Sections kann ich eigentlich jedes beliebige Template hinzufügen. Natürlich kann ich auch direkt im Template ein include angeben, zum Beispiel header und footer habe ich ausgelagert, aber is ja erstmal nicht so wichtig. Dieses mutliply ist eigentlich so ähnlich wie eine foreach Schleife, allerdings will ich die Möglichkeit haben, mehrere multiplys zu verschachteln.
                Also wenn ich in der For-Schleife der PHP Datei noch ne For-Schleife mache und das ganze dann dem navi zum Beispiel unter dem Namen subnavi hinzufüge, dann kann ich im Template im navi-{multiply} noch ein subnavi-{mutliply} definieren.
                Bei meinem "Template-System" habe ich noch die möglichkeit Areas zu verstecken. PHP Code wird rausgefiltert und natürlich überflüßige Dinge entfernt (wenn zum Beispiel irgendwo ein {section} übrigbleibt oder so)

                Joar ich glaube das war es erstmal so.

                Kommentar


                • #9
                  Hallo KarlEgon,

                  wenn ich das richtig sehe, sollte die Anforderung also mit ein paar Templates und DocumentController, die die Ausgabelogik kapseln zu erschlagen sein. Weitere "includes" in Templates können dabei ganz einfach mit dem <core:importdesign /> erledigt werden. Zur Gestaltung von wiederverwendbaren Elementen kannst du das <html:template />-Tag nehmen. Dieses steht im APF-DOM-Model im DocumentController (=MVC-Controller) dann als eigenes Objekt zur Verfügung und kann entsprechend genutzt werden. Hier die relevanten Stellen in der Doku:

                  * Adventure PHP Framework - Standard TagLibs
                  * Adventure PHP Framework - Standard TagLibs

                  Falls eine Ausgabe von Objekten in einer Liste direkt stattfinden kann, ist der Iterator-Tag (siehe Adventure PHP Framework - Standard TagLibs) eine ganz nette Alternative.

                  Deine Templates würden dann in etwa so aussehen:

                  main.html:
                  Code:
                  <html>
                  <head>
                          <title>{$titel}</title>
                      </head> 
                      <body>
                          <div id="header">
                            <core:importdesign namespace="sites::karlegon::pres::template" template="header" />
                          </div> 
                          <div id="left">
                            <core:importdesign namespace="sites::karlegon::pres::template" template="left" />
                          </div> 
                          <div id="right">
                            <core:importdesign namespace="sites::karlegon::pres::template" template="right" />
                          </div> 
                          <div id="content">
                            <core:importdesign namespace="sites::karlegon::pres::template" template="content" />
                          </div> 
                          <div id="footer">
                            <core:importdesign namespace="sites::karlegon::pres::template" template="footer" />
                          </div>
                      </body>
                  </html>
                  Die jeweiligen "Subtemplates" enhalten dann die entsprechenden statischen oder dynamischen Inhalte. Für die Generierung der dynamischen Inhalte können dann DocumentController (siehe Adventure PHP Framework - Controller) genutzt werden. Ein expliziteres Beispiel kann ich dir basteln, wenn du mir weiteren Input gibst. Die Verschachtelungstiefe und Kombinationsmöglichkeiten bei den einzelnen Bereichen (Templates) ist uneingeschränkt, sprich du erhälst maximale Wiederverwendbarkeit.

                  Noch ein Controller-Beispiel zum Schluss: den Fertigstellungsgrad füllst du im APF so aus:

                  Template-Datei:
                  Code:
                  <@controller namespace="sites::karlegon::pres::controller" class="status_controller" file="status_controller" @>
                  <div id="status">
                  
                      Fertigstellungsgrad: <html:placeholder name="ready"/> %
                  
                  </div>
                  Controller-Datei:
                  PHP-Code:
                  class status_controller extends baseController
                  {
                     function 
                  transformContent(){
                        
                  $this->setPlaceHolder('ready',20);   
                     }

                  Um dein Haupt-Template ausgeben zu können brauchst du noch eine Bootstrap-Datei. Diese halt folgende Gestalt:

                  PHP-Code:
                  include_once('./apps/core/pagecontroller/pagecontroller.php');
                  $Page = new Page('helloworld');
                  $Page->loadDesign('sites::karlegon','pres/templates/main');
                  echo 
                  $Page->transform(); 
                  And now over to you!
                  Viele Grüße,
                  Dr.E.

                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                  1. Think about software design before you start to write code!
                  2. Discuss and review it together with experts!
                  3. Choose good tools (-> Adventure PHP Framework (APF))!
                  4. Write clean and reusable software only!
                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

                  Kommentar


                  • #10
                    Sieht schonmal nicht schlecht aus, aber kann ich auch dynamisch Templates hinzufügen über dieses <core:importdesign> ? So das ich erst im Controller sage welche Templates benutzt werden sollen und für eine "Variable" sollen auch mehrere Templates eingesetzt werden können.

                    Gibt es irgendwo ne PDF Version der Dokumentation? Oder nur diese CHM Versionen?

                    Kommentar


                    • #11
                      Hallo KarlEgon,

                      aber kann ich auch dynamisch Templates hinzufügen über dieses <core:importdesign> ?
                      an sich steht es dir frei, was du genau machen möchtest. Der <core:importdesign /> hilft dir dabei lediglich. Die Funktion könntest du kedoch aber auch selbst abbilden - nur soviel zur Idee.
                      Der importdesign-Tag bietet zusätzlich die Möglichkeit, das Template per URL-Parameter zu steuern. Hierzu musst du die Definition entsprechend anpassen:

                      Code:
                      <core:importdesign namespace="my::namespace" template="[my_view_control_param = start]" incparam="my_view_control_param" />
                      Damit kannst du beispielsweise durch den URL-Parameter my_view_control_param steuern, welches Template im Namespace my::namespace geladen wird. Möchtest du auch den Namespace durch irgendetwas beeinflussen, kannst du dir auch eine neue Taglib schreiben (siehe Adventure PHP Framework - TagLibs erstellen), die diese Funktion abbildet.

                      So das ich erst im Controller sage welche Templates benutzt werden sollen und für eine "Variable" sollen auch mehrere Templates eingesetzt werden können.
                      Die <html:template />-Tags kannst du im Controller verwenden und auch steuern - ja. Das Inkludieren von weiteren "Subtemplates" per importdesign hat jedoch eine andere Aufgabe: intern baut der PageController des APF einen Objektbaum aus den unterschiedlichen Template-Dateien auf und verwaltet diesen. Diese Parse-Operation passiert beim Aufruf der Methode loadDesign() (siehe oben). Anschließend steht dir bei der Transformation ein kompletter Objektbaum zur Verarbeitung zur Verfügung, den du entsprechend nutzen kannst. Um nun das Einbinden von weiteren "Subtemplates" dynamisch zu gestalten solltest du nicht während der Transformation eingreifen, sondern schon während des Parsens. Letzteres kannst du ganz einfach dadurch erreichen, dass du eine eigene TagLib schreibst, die die onParseTime() implementiert. Dort bist du dann frei zu entscheiden, welches Template wie eingebunden wird. Exakt so funktioniert auch die <core:importdesign /> Tag-Library (siehe auch Adventure PHP Framework - Standard TagLibs). Möchtest du also z.B. über ein Model-Objekt beeinflussen können, welches Template geladen werden soll, kannst du das durch das <fcon:importdesign />-Tag oder eine eigene Tag-Logik ganz einfach abbilden. Da zu diesem Thema auch im APF-Forum eine Diskussion stattfindet hier noch der Link dazu. Dort findest du auch nochmal eine Erläuterung zum Verhalten einer TagLib: forum.adventure-php-framework.org [de] &bull; Thema anzeigen - GenericORMapper

                      Ich hoffe, das hilft dir weiter!

                      Gibt es irgendwo ne PDF Version der Dokumentation? Oder nur diese CHM Versionen?
                      Die API-Dokumentation ist in gezipptem HTML und als CHM verfügbar. Die Anwender- und Entwickler-Dokumentation ist nur online verfügbar.
                      Viele Grüße,
                      Dr.E.

                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                      1. Think about software design before you start to write code!
                      2. Discuss and review it together with experts!
                      3. Choose good tools (-> Adventure PHP Framework (APF))!
                      4. Write clean and reusable software only!
                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

                      Kommentar


                      • #12
                        Mhhh ok dann werde ich mal ein bisschen mich daran versuchen und ein paar Beispiele durchgehen. Mal schauen ob ich es schaffe meine Seite umzustellen ^^

                        Kommentar


                        • #13
                          Mal schauen ob ich es schaffe meine Seite umzustellen ^^
                          Solltest du Hilfe brauchen, meld dich einfach!
                          Viele Grüße,
                          Dr.E.

                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                          1. Think about software design before you start to write code!
                          2. Discuss and review it together with experts!
                          3. Choose good tools (-> Adventure PHP Framework (APF))!
                          4. Write clean and reusable software only!
                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

                          Kommentar


                          • #14
                            Ich habe nochmal eine Frage wegen dem Aufbau meines Projekts. Im Moment sieht es folgerndermaßen aus:
                            /
                            /classes Alle Klassen, die der MainCore verwaltet
                            /config Alle Dateien, die für die Konfiguration benötigt werden
                            /controller Der MainCore + MainCore Klasse
                            /design Alle Dateien, die mit dem Design zu tun haben(z.B. Stylesheet, Bilder)
                            /functions Alle PHP Dateien die Funktionen beinhalten
                            /source PHP Dateien, die Funktionen usw. aufrufen
                            /subsite PHP Dateien, die überprüfen, zu welcher source PHP Datei weitergeleitet wird
                            /templates Die Templates für das Spiel
                            /templates/… Verschiedene Unterordner zur besseren Übersicht

                            Nun ist die Frage wie ich das ganze am besten umsetze.
                            Meine index.php sieht im groben so aus:
                            PHP-Code:
                            //Sessions
                            //Klasse initialisieren
                            if(!$user->loggedin()) {
                                
                            //User ist ausgeloggt
                                
                            switch($_GET['site']) {
                                     
                            //Case Blöcke in denen zu den subsites weitergeleitet wird
                                
                            }
                            } else {
                                
                            //User ist eingeloggt
                                
                            switch(... //Wie beim ausgeloggten Zustand

                            Bin am überlegen, wie ich es umsetze, weil sonst habe ich immer in den einzelnen source Dateien einfach $tpl->assign(...) aufgerufen, dies soll ja nun durch einen Controller geregelt werden.

                            Und bei dem dynamischen einbinden von Templates bin ich auch noch nicht so ganz durchgestiegen.

                            Kommentar


                            • #15
                              Hallo KarlEgon,

                              bei der Verwendung des APF ergänzt sich deine Struktur noch durch die Ordner core, modules und tools. Diese beinhalten die Framework-Komponenten. Die Addressierung erfolgt dabei relativ zum Basis-Ordner, in dem sich die Ordner core, modules und tools befinden. Konfigurationsdateien werden im APF auch in einem eigenen Ordner (config) abgelegt. Möchtest du also in der oben beschriebenen index.php ein template im Ordner templates addressieren, so setzt sich der Namespace aus dem Ordner-Pfad ab dem Basis-Ordner zusammen (z.B. templates::mymodule:res). Ich empfehle dir jedoch, die Strukturierung ein wenig zu ändern um die Zugehörigkeitbesser abbilden zu können. Eine Seite besteht in aller Regel aus mehrern Templates, Controllern usw. gehört jedoch thematisch zusammen. Hierhat sich bewährt, die wiederverwendbaren Module im ordner modules abzulegen und die Webseiten oder Applikationen unter sites. In deinem Fall würdaen alle Dateien zu deiner Webseite dann unter /sites/<name_der_seite>/* abgelegt werden.

                              Ich kann dir gerne mal einen Vorschlag zur Strukturierung machen, da wäre es aber sinnvoll eine komplette Datei-Liste der genannten ordner einsehen zu können.

                              Bin am überlegen, wie ich es umsetze, weil sonst habe ich immer in den einzelnen source Dateien einfach $tpl->assign(...) aufgerufen, dies soll ja nun durch einen Controller geregelt werden.

                              Und bei dem dynamischen einbinden von Templates bin ich auch noch nicht so ganz durchgestiegen.
                              Ich würde hier so vorgehen:

                              * Definition eines globalen "Rahmen-Templates", das die Struktur vorgibt.
                              * Das "Rahmen-Template" besitzt mehrere importdesign-Tags, die die einzelnen Bereiche (Menü, ...) einbinden.
                              * In den einzelnen Bereichs-Templates werden die Inhalte dynamisch (sofern erforderlich) mit entsprechenden DocumentController erzeugt.

                              In den Controllern nutzt du die in den Template-Dateien definierten Templates bzw. Tags um die Ausgabe zu generieren. Für die Listendarstellung habe ich unter Adventure PHP Framework - Templates einige Beispiele zusammengestellt. Weitere Beispiele finden sich unter

                              * Adventure PHP Framework - Webseite erstellen
                              * Adventure PHP Framework - Kommentar Funktion Tutorial

                              Meine index.php sieht im groben so aus:
                              Die einfachste Lösung ist hier: der Controller, der den personalisierten Bereich darstellt fragt die jeweils relevante Komponente (hier $user) nach einem Indikator, ob ein Formular oder die eingeloggte Ansicht angezeigt werden soll. das könnte so aussehen:

                              Template:
                              Code:
                              <@controller namespace="..." file="personalized_controller" class="personalized_controller" @>
                              
                              <html:template name="loggedin">
                                ...
                              </html:template>
                              
                              <core:addtaglib namespace="tools::html::taglib" prefix="html" class="form" />
                              <html:form name="login">
                                ...
                              </html:form>
                              Controller:
                              PHP-Code:
                                 class personalized_controller extends baseController
                                 
                              {  
                                    function 
                              transformContent(){
                                       
                              $user = ...;
                                       if(!
                              $user->loggedin()){
                                          
                              $form = &$this->__getForm('login');
                                          
                              $form->transformOnPlace();         
                                        
                              // end if
                                       
                              }
                                       else{
                                          
                              $tmpl = &$this->__getTemplate('loggedin');
                                          
                              $tmpl->transformOnPlace();         
                                       }
                                    }
                                 } 
                              Wichtig ist, dass du sowohl gedanklich als auch in der Implementierung stärker segmentierst. Global relevante Parameter müssen dabei auch global zur Verfügung gestellt werden (z.B. $user). Im konkreten Teilbereich kümmerst du dich dann eben nur um das, worum du dich auch kümmern möchtest. Ich weiß, das erfordert ein wenig Umdenken, aber den Vorteil wirst du sehr schnell erkennen.

                              Ich hoffe, das hilft dir weiter!
                              Viele Grüße,
                              Dr.E.

                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                              1. Think about software design before you start to write code!
                              2. Discuss and review it together with experts!
                              3. Choose good tools (-> Adventure PHP Framework (APF))!
                              4. Write clean and reusable software only!
                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

                              Kommentar

                              Lädt...
                              X