<?php
/*
Licence et conditions d'utilisations-----------------------------------------------------------------------------
-English---------------------------------------------------------------------------------------------------------
Copyright (C) 2001 - AUTHOR
- ANDRE thierry
- ADDING
- VILDAY Laurent.
- MOULRON Diogène.
- DELVILLE Romain.
- BOUCHERY Frederic.
- PERRICHOT Florian.
- RODIER Phillipe.
- HOUZE Sébastien.
- DECLEE Frédéric.
- HORDEAUX Sébastien.
- LELARGE Guillaume.
- GAUTHIER Jérémy.
- CASANOVA Matthieu.
- KELLER Christophe.
This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General
Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option)
any later version.
This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
details.
You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to :
Free Software Foundation,
Inc., 59 Temple Place,
Suite 330, Boston,
MA 02111-1307, Etats-Unis.
------------------------------------------------------------------------------------------------------------------
-Français---------------------------------------------------------------------------------------------------------
ModeliXe est distribué sous licence LGPL, merci de laisser cette en-tête, gage et garantie de cette licence.
ModeliXe est un moteur de template destiné à être utilisé par des applications écrites en PHP.
ModeliXe peut être utilisé dans des scripts vendus à des tiers aux titres de la licence LGPL. ModeliXe n'en reste
pas moins OpenSource et libre de droits en date du 23 Août 2001.
Copyright (C) 2001 - Auteur
- ANDRE thierry
- Ajouts
- VILDAY Laurent.
- MOULRON Diogène.
- DELVILLE Romain.
- BOUCHERY Frederic.
- PERRICHOT Florian.
- RODIER Phillipe.
- HOUZE Sébastien.
- DECLEE Frédéric.
- HORDEAUX Sébastien.
- LELARGE Guillaume.
- GAUTHIER Jérémy.
- CASANOVA Matthieu.
- KELLER Christophe.
Cette bibliothèque est libre, vous pouvez la redistribuer et/ou la modifier selon les termes de la Licence Publique
Générale GNU Limitée publiée par la Free Software Foundation version 2.1 et ultérieure.
Cette bibliothèque est distribuée car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite,
y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence
Publique Générale GNU Limitée pour plus de détails.
Vous devez avoir reçu une copie de la Licence Publique Générale GNU Limitée en même temps que cette bibliothèque;
si ce n'est pas le cas, écrivez à:
Free Software Foundation,
Inc., 59 Temple Place,
Suite 330, Boston,
MA 02111-1307, Etats-Unis.
Pour tout renseignements mailez à modelixe@free.fr ou thierry.andre@freesbee.fr
--------------------------------------------------------------------------------------------------------------------
*/
//Initialisation de l'include_path
$os = ((stristr(getenv('SERVER_SOFTWARE'), 'win') || stristr(getenv('SERVER_SOFTWARE'), 'microsoft'))? ';' : ':');
$path = ((defined('MX_GENERAL_PATH'))? MX_GENERAL_PATH : '').$os.((defined('MX_ERROR_PATH'))? MX_ERROR_PATH : '').$os.ini_get('include_path');
ini_set('include_path', $path);
//Inclusion du fichier de configuration et de Error Manager
require_once('Mxconf.php');
require_once('ErrorManager.php');
//Désactivation de magic_quotes_runtime de php.ini
if (get_magic_quotes_runtime()) set_magic_quotes_runtime(0);
class ModeliXe extends ErrorManager{
var $template = '';
var $absolutePath = '';
var $relativePath = '';
var $sessionParameter = '';
var $mXParameterFile = '';
var $mXTemplatePath = '';
var $mXCachePath = '';
var $mXUrlKey = '';
var $outputSystem = '/>';
var $flagSystem = 'xml';
var $adressSystem = 'relative';
var $mXVersion = 'beta 7.3';
var $mXCacheDelay = 0;
var $debut = 0;
var $fin = 0;
var $ExecutionTime = 0;
var $mXcompress = false;
var $mXsetting = false;
var $mXmodRewrite = false;
var $performanceTracer = false;
var $mXoutput = false;
var $mXsignature = true;
var $isTemplateFile = true;
var $templateContent = array();
var $sheetBuilding = array();
var $deleted = array();
var $replacement = array();
var $loop = array();
var $IsALoop = array();
var $xPattern = array();
var $formField = array();
var $checker = array();
var $attribut = array();
var $attributKey = array();
var $htmlAtt = array();
var $select = array();
var $hidden = array();
var $image = array();
var $text = array();
var $father = array();
var $son = array();
var $plugInMethods = array();
var $flagArray = array(0 => 'hidden', 1 => 'select', 2 => 'image', 3 => 'text', 4 => 'checker', 5 => 'formField');
var $attributArray = array(0 => 'attribut');
//MX Generator----------------------------------------------------------------------------------------------------
//Constructeur de ModeliXe
function ModeliXe ($template, $sessionParameter = '', $templateFileParameter = '', $cacheDelay = -1){
$this -> ErrorManager();
$time = explode(' ',microtime());
$this -> debut = $time[1] + $time[0];
//Gestion des paramètres par défaut
//Definition du systeme de compression
if (defined('MX_COMPRESS')) $this -> SetMxCompress(MX_COMPRESS);
//Activation du mode rewrite
if (defined('MX_REWRITEURL')) $this -> SetMxModRewrite(MX_REWRITEURL);
//Activation de la signature
if (defined('MX_SIGNATURE')) $this -> SetMxSignature(MX_SIGNATURE);
//Définition du répertoire de template
if (defined('MX_TEMPLATE_PATH')) $this -> SetMxTemplatePath(MX_TEMPLATE_PATH);
//Définition du fichier de paramétrage
if (defined('MX_DEFAULT_PARAMETER') && ! $templateFileParameter)
$this -> SetMxFileParameter(MX_DEFAULT_PARAMETER);
elseif ($templateFileParameter != '')
$this -> SetMxFileParameter($templateFileParameter);
//Définition du type de balisage
if (defined('MX_FLAGS_TYPE')) $this -> SetMxFlagsType(MX_FLAGS_TYPE);
//Définition du type de balisage en sortie
if (defined('MX_OUTPUT_TYPE')) $this -> SetMxOutputType(MX_OUTPUT_TYPE);
//Définition du répertoire de cache
if (defined('MX_CACHE_PATH')) $this -> SetMxCachePath(MX_CACHE_PATH);
if (defined('MX_CACHE_DELAY')) $this -> SetMxCacheDelay(MX_CACHE_DELAY);
if ($cacheDelay >= 0 && $cacheDelay != '') $this -> SetMxCacheDelay($cacheDelay);
//Activation du traceur de performance
if (defined('MX_PERFORMANCE_TRACER') && MX_PERFORMANCE_TRACER == 'on') $this -> performanceTracer = true;
//Gestion des paramètres de sessions
if ($sessionParameter) $this -> sessionParameter = $sessionParameter;
//Instanciation de la ressource templates
if (@is_file($this -> mXTemplatePath.$template)) $this -> template = $template;
elseif (isset($template)) {
$this -> template = $template;
$this -> isTemplateFile = false;
}
else $this -> ErrorTracker (5, 'No template file defined.', 'ModeliXe', __FILE__, __LINE__);
//Affectation du path d'origine
if ($this -> ErrorChecker()) {
$this -> absolutePath = substr(basename($this -> template), 0, strpos(basename($this -> template), '.'));
$this -> relativePath = $this -> absolutePath;
}
}
//Setting ModeliXe -------------------------------------------------------------------------------------------
//Méthode d'instanciation du template
function SetModelixe($out = ''){
if ($this -> mXsetting) $this -> ErrorTracker(4, 'You can\'t re-use this method after instanciate ModeliXe once time.', 'SetModelixe', __FILE__, __LINE__);
if ($out) $this -> mXoutput = true;
//Test du cache et insertion éventuelle
if ($this -> mXCacheDelay > 0){
$this -> mXUrlKey = $this -> GetMD5UrlKey();
if ($this -> MxCheckCache()) $this -> MxGetCache();
}
//Initialisation de la classe
$this -> GetMxFile();
if ($this -> ErrorChecker()) $this -> MxParsing($this -> templateContent[$this -> absolutePath]);
$this -> mXsetting = true;
}
//Instanciation de la compression
function SetMxCompress($arg = ''){
if ($arg != 'on') $this -> mXcompress = false;
else $this -> mXcompress = true;
return $this -> mXcompress;
}
//Instanciation du mode rewrite
function SetMxModRewrite($arg = ''){
if ($arg != 'on') $this -> mXmodRewrite = false;
else $this -> mXmodRewrite = true;
return $this -> mXmodRewrite;
}
//Instanciation de la signature
function SetMxSignature($arg = ''){
if ($arg != 'on') $this -> mXsignature = false;
else $this -> mXsignature = true;
return $this -> mXsignature;
}
//Instanciation du template path
function SetMxTemplatePath($arg = ''){
if ($this -> mXsetting) $this -> ErrorTracker(1, 'You can\'t use this method after instanciate ModeliXe with setModeliXe method, it will be without effects.', 'SetMxTemplatePath', __FILE__, __LINE__);
else {
if ($arg[strlen($arg) - 1] != '/' && $arg) $arg .= '/';
if (! is_dir($arg)) $this -> ErrorTracker(5, 'The MX_TEMPLATE_PATH (<b>'.$arg.'</b>) is not a directory.', 'SetMxTemplatePath', __FILE__, __LINE__);
else $this -> mXTemplatePath = $arg;
}
return $this -> mXTemplatePath;
}
//Instanciation du fichier de paramètre
function SetMxFileParameter($arg = ''){
if ($arg != '' && ! is_file($arg)) $this -> ErrorTracker(1, 'The parameter\'s file path (<b>'.$arg.'</b>) does not exist.', 'SetMxFileParameter', __FILE__, __LINE__);
else $this -> mXParameterFile = $arg;
return $this -> mXParameterFile;
}
//Instanciation du balisage du template
function SetMxFlagsType($arg){
if ($this -> mXsetting) $this -> ErrorTracker(1, 'You can\'t use this method after instanciate ModeliXe with setModeliXe method, it will be without effects.', 'SetMxFlagsType', __FILE__, __LINE__);
else {
switch (strtolower($arg)){
case 'classical':
$this -> flagSystem = 'classical';
break;
case 'pear':
$this -> flagSystem = 'classical';
break;
case 'xml':
$this -> flagSystem = 'xml';
break;
default:
$this -> ErrorTracker(2, 'This type of flag system ('.$arg.') is unrecognized.', 'SetMxFlagsType', __FILE__, __LINE__);
}
}
return $this -> flagSystem;
}
//Instanciation du balisage de sortie
function SetMxOutputType($arg){
if ($this -> mXsetting) $this -> ErrorTracker(1, 'You can\'t use this method after instanciate ModeliXe with setModeliXe method, it will be without effects.', 'SetMxOutputType', __FILE__, __LINE__);
else {
switch (strtolower($arg)){
case 'xhtml':
$this -> outputSystem = '/>';
break;
case 'html':
$this -> outputSystem = '>';
break;
default:
$this -> ErrorTracker(2, 'This type of output flag system ('.$arg.') is unrecognized.', 'SetMxOutputType', __FILE__, __LINE__);
}
}
return $arg;
}
//Instanciation du répertoire de cache
function SetMxCachePath($arg){
if ($this -> mXsetting) $this -> ErrorTracker(1, 'You can\'t use this method after instanciate ModeliXe with setModeliXe method, it will be without effects.', 'SetMxCachePath', __FILE__, __LINE__);
else {
if ($arg[strlen($arg) - 1] != '/') $arg .= '/';
if (! is_dir($arg) && $arg != '') $this -> ErrorTracker(5, 'The MxCachePath (<b>'.$arg.'</b>) is not a directory.', 'SetMxCachePath', __FILE__, __LINE__);
elseif ($arg) $this -> mXCachePath = $arg;
}
return $this -> mXCachePath;
}
//Instanciation du délai de cache
function SetMxCacheDelay($arg){
if ($this -> mXsetting) $this -> ErrorTracker(1, 'You can\'t use this method after instanciate ModeliXe with setModeliXe method, it will be without effects.', 'SetMxCachePath', __FILE__, __LINE__);
elseif ($arg >= 0) $this -> mXCacheDelay = (integer)$arg;
return $this -> mXCacheDelay;
}
//Instanciation des paramètres de session
function SetMxSession($arg){
$this -> sessionParameter = $arg;
}
//Setting tools -----------------------------------------------------------------------------------------------
//Recherche du fichier de template
function GetMxFile($source = ''){
if (! $source) $source = $this -> mXTemplatePath.$this -> template;
if (! $read = @fopen($source, 'rb')) $this -> ErrorTracker (3, 'Can\'t open this template file (<b>'.$source.'</b>) in read, see for change the read modalities.', 'GetMxFile', __FILE__, __LINE__);
else {
if (! $result = @fread($read, filesize($source))) $this -> ErrorTracker (3, 'Can\'t read the template file (<b>'.$source.'</b>), see for file format and integrity.', 'GetMxFile', __FILE__, __LINE__);
fclose($read);
}
if (empty($result)) $result = '[no parsing, template file not found or invalid]';
if ($this -> mXsignature && $source != $this -> mXTemplatePath.$this -> template) $result = "\n<!--[ModeliXe ".$this -> mXVersion.']-- [StartOf'.$dyn.'Inclusion : '.$source."] -->\n\n".$result."\n\n<!--[ModeliXe ".$this -> mXVersion.']-- [EndOf'.$dyn.'Inclusion : '.$source."] -->\n";
//Affectation du path d'origine, et du content du template
if ($source == $this -> mXTemplatePath.$this -> template) $this -> templateContent[$this -> absolutePath] = $result;
else return $result;
}
//Lecture du fichier de configuration et parsing
function GetParameterParsing ($template){
$ligne = '';
$signal = '';
if (! $read = @fopen($this -> mXParameterFile, 'r')) $this -> ErrorTracker(4, 'The mXParameterFile (<b>'.$this -> mXParameterFile.'</b>) can\'t be open, the first parsing can\'t be do.', 'GetParameterParsing', __FILE__, __LINE__);
for ($multi = false; !feof($read) && $this -> ErrorChecker(); $ligne = trim(@fgets($read, 1200))){
if (strlen($ligne)) {
if ($ligne[0] == '#' && $ligne[1] != '#'){
//Changement d'état pour les paramètres
switch(strtolower($ligne)){
case '#flag' :
$signal = 'flag';
break;
case '#attribut' :
$signal = 'attribut';
break;
default :
$this -> ErrorTracker(3, '<b>'.$ligne.' </b> is not a valid section parameter type', 'GetParameterParsing', __FILE__, __LINE__);
break;
}
}
else {
if($ligne[0] == '#') $ligne = substr($ligne,1);
if (! $multi){
$keyC = chop(substr($ligne, 0, strpos($ligne, '=') - 1));
//Gestion du multiligne, début d'une valeur sur plusieurs lignes
if (($content = ltrim(substr($ligne, strpos($ligne, '=') + 1))) && substr($content, 0, 3) == '"""') {
$multi = true;
$content = substr($content, 3);
}
}
//Gestion du multiligne, fin d'une valeur sur plusieurs lignes
else {
if (substr($ligne, strlen($ligne) - 3) == '"""') {
$multi = false;
$content .= ' '.substr($ligne, 0, strpos($ligne, '"""'));
}
else $content .= ' '.$ligne;
}
//Si nous ne sommes pas dans une valeur sur plusieurs lignes (valeur compléte)
if (! $multi){
switch ($this -> flagSystem){
case 'xml':
$flagRegexp = '<mx:preformating id="'.$keyC.'"/>';
$attRegexp = 'mXpreformating="'.$keyC.'"';
break;
case 'classical':
$flagRegexp = '{preformating id="'.$keyC.'"}';
$attRegexp = '{preformatingAtt id="'.$keyC.'"}';
break;
}
if ($signal == 'flag') $template = str_replace($flagRegexp, $content, $template);
if ($signal == 'attribut') $template = str_replace($attRegexp, $content, $template);
}
}
}
}
if ($read) @fclose($read);
return $template;
}
//MX Builder-----------------------------------------------------------------------------------------
function MxBloc($index, $mod, $value = ''){
$mod = substr(strtolower($mod), 0, 4);
if ($this -> adressSystem == 'relative') {
if ($index) $index = $this -> relativePath.'.'.$index;
else $index = $this -> relativePath;
}
else $index = $this -> absolutePath.'.'.$index;
$fat = $this -> father[$index];
if (! $fat && $index != $this -> absolutePath) $this -> ErrorTracker(2, 'The current path (<b>'.$index.'</b>) does not exist, or was deleting, him or his father, before.', 'MxBloc', __FILE__, __LINE__);
switch ($mod){
//Looping
case 'loop':
$this -> MxLoopBuilder($index);
break;
//Deleting
case 'dele':
$this -> sheetBuilding[$index] = ' ';
$this -> loop[$index] = '';
$this -> deleted[$index] = true;
break;
//Concatenating
case 'appe':
if (@is_file($value)) $value = $this -> GetMxFile($value);
$this -> templateContent[$index] .= $value;
$this -> MxParsing($value, $index, $this -> father[$index]);
break;
//Replacing
case 'repl':
if (@is_file($value)) $value = $this -> GetMxFile($value);
$this -> sheetBuilding[$index] = $value;
$this -> replacement[$index] = true;
break;
//Modify template references of this bloc
case 'modi':
$this -> sheetBuilding[$index] = '';
$this -> loop[$index] = '';
if (@is_file($value)) $value = $this -> GetMxFile($value);
$this -> templateContent[$index] = $value;
$this -> MxParsing($value, $index, $this -> father[$index]);
break;
//Reset, destroy all references
case 'rese':
$this -> sheetBuilding[$index] = '';
$this -> loop[$index] = '';
$this -> templateContent[$index] = '';
$ind = substr($index, strrpos($index, '.') + 1);
$this -> templateContent[$fat] = str_replace('<mx:inclusion id="'.$ind.'"/>', '', $this -> templateContent[$fat]);
$this -> deleted[$index] = true;
$this -> xPattern['inclusion'][$index] = '';
break;
}
}
function MxFormField($index, $type, $name, $value, $attribut = ''){
if ($this -> adressSystem == 'relative') $index = $this -> relativePath.'.'.$index;
$end = $this -> outputSystem;
switch (strtolower($type)){
case 'text':
$replace = '<input type="text" name="'.$name.'" value="'.$value.'" '.$attribut.' '.$this -> htmlAtt[$index].$end;
break;
case 'password':
$replace = '<input type="password" name="'.$name.'" value="'.$value.'" '.$attribut.' '.$this -> htmlAtt[$index].$end;
break;
case 'textarea':
$replace = '<textarea name="'.$name.'" '.$attribut.' '.$this -> htmlAtt[$index].' >'.$value.'</textarea>';
break;
case 'file':
$replace = '<input type="file" name="'.$name.'" value="'.$value.'" '.$attribut.' '.$this -> htmlAtt[$index].$end;
break;
case 'submit':
$replace = '<input type="submit" name="'.$name.'" value="'.$value.'" '.$attribut.' '.$this -> htmlAtt[$index].$end;
break;
case 'reset':
$replace = '<input type="reset" name="'.$name.'" value="'.$value.'" '.$attribut.' '.$this -> htmlAtt[$index].$end;
break;
case 'button':
$replace = '<input type="button" name="'.$name.'" value="'.$value.'" '.$attribut.' '.$this -> htmlAtt[$index].$end;
break;
case 'image':
$replace = '<input type="image" name="'.$name.'" '.$attribut.' '.$this -> htmlAtt[$index].$end;
break;
default:
$this -> ErrorTracker(3, 'This type (<b>'.$type.'</b>) is unknown for this formField manager.', 'MxFormField', __FILE__, __LINE__);
}
$this -> formField[$index] = $replace;
}
function MxImage($index, $imag, $title = '', $attribut = '', $size = false){
if ($this -> adressSystem == 'relative') $index = $this -> relativePath.'.'.$index;
$end = $this -> outputSystem;
if (($ima = '<img src="'.$imag.'"') && ! $size) {
$size = @getimagesize($imag);
$ima .= ' '.$size[3];
}
if ($title == 'no') $ima .= ' ';
elseif ($title) $ima .= ' alt="'.$title.'" ';
else $ima .= ' alt="no title - source : '.basename($imag).'" ';
if ($attribut) $ima .= $attribut;
$ima .= ' '.$this -> htmlAtt[$index].$end;
$this -> image[$index] = $ima;
}
function MxText($index, $att){
if ($this -> adressSystem == 'relative') $index = $this -> relativePath.'.'.$index;
$this -> text[$index] = $att;
}
function MxAttribut($index, $att){
if ($this -> adressSystem == 'relative') $index = $this -> relativePath.'.'.$index;
//Gestion des mailto et des javascripts dans les href
if (strtolower($this -> attributKey[$index]) == 'mailto' || strtolower($this -> attributKey[$index]) == 'javascript') $marqueur = ' href="';
//Gestion multi-attributs
if (! ((isset($this -> attribut[$index]))? chop($this -> attribut[$index]): false) ) {
if ($marqueur) $this -> attribut[$index] = $marqueur.$this -> attributKey[$index].':'.$att.'"';
else $this -> attribut[$index] = $this -> attributKey[$index].'="'.$att.'"';
}
else {
if (empty($this -> attribut[$this -> attribut[$index]])) {
if ($marqueur) $this -> attribut[$this -> attribut[$index]] = ' '.$marqueur.$this -> attributKey[$index].':'.$att.'"';
else $this -> attribut[$this -> attribut[$index]] = ' '.$this -> attributKey[$index].'="'.$att.'"';
}
else {
if ($marqueur) $this -> attribut[$this -> attribut[$index]] .= $marqueur.$this -> attributKey[$index].':'.$att.'"';
else $this -> attribut[$this -> attribut[$index]] .= ' '.$this -> attributKey[$index].'="'.$att.'"';
}
}
}
function MxSelect($index, $name, $value, $arrayArg, $defaut = '', $multiple = '', $javascript = '') {
if ($this -> adressSystem == 'relative') $index = $this -> relativePath.'.'.$index;
$sel = '';
if ($multiple && $multiple > 0) {
$attribut = 'size="'.$multiple.'" multiple="multiple" ';
$post = '[]';
}
else {
$attribut = '';
$post = '';
}
//Build of a select tag from an array
if (is_array($arrayArg)){
$sel = "\n".'<select name="'.$name.$post.'" ';
if ($attribut) $sel .= $attribut.' ';
if ($javascript) $sel .= $javascript;
$sel .= ' '.$this -> htmlAtt[$index].' '.">\n";
if (isset($defaut) && $defaut) $sel .= "\t".'<option value="#">'.$defaut.'</option>'."\n";
$debut = 0;
$fin = count($arrayArg);
reset($arrayArg);
while (list($cle, $Avalue) = each($arrayArg)){
$test = 0;
//Build of multiple choice select from a value array
if (is_array($value) && $multiple > 0){
reset($value);
while (list($Vcle, $Vvalue) = each($value)){
if ($cle == $Vvalue && $Vvalue) {
$sel .= "\t".'<option value="'.$cle.'" selected="selected">'.$Avalue.'</option>'."\n";
$test = 1;
break;
}
}
if ($test == 0) $sel .= "\t".'<option value="'.$cle.'">'.$Avalue.'</option>'."\n";
}
//Simple select
else {
if ($value != '' && $cle == $value) $sel .= "\t".'<option value="'.$cle.'" selected="selected">'.$Avalue.'</option>'."\n";
else $sel .= "\t".'<option value="'.$cle.'">'.$Avalue.'</option>'."\n";
}
}
}
else {
$this -> ErrorTracker(2, 'This function need an Array in fourth argument to build the select <b>'.$index.'</b>.', 'MxSelect', __FILE__, __LINE__);
$sel = '<select name="'.$name.'">'."\n\t".'<option value="null">No record found</option>'."\n";
}
$sel .= '</select>';
$this -> select[$index] = $sel;
}
function MxUrl($index, $urlArg, $param = '', $noSid = false) {
if ($this -> adressSystem == 'relative') $index = $this -> relativePath.'.'.$index;
$ok = false;
if ($this -> sessionParameter && ! $noSid) {
if ($this -> mXCacheDelay > 0) $urlArg .= '?<mx:session />';
else $urlArg .= '?'.$this -> sessionParameter;
$ok = true;
}
if (is_string($param) && $param) {
$param = explode('&',$param);
for($i = 0; $i < count($param) && $param[$i]; $i++){
$cle = explode('=', $param[$i]);
if (! $this -> mXmodRewrite){
if($i == 0 && !$ok) $urlArg .= '?'.urlencode($cle[0]).'='.urlencode($cle[1]);
else $urlArg .= '&'.urlencode($cle[0]).'='.urlencode($cle[1]);
}
else {
if($i == 0 && !$ok) $urlArg .= '/'.urlencode($cle[0]).'/'.urlencode($cle[1]);
else $urlArg .= '/'.urlencode($cle[0]).'/'.urlencode($cle[1]);
}
}
}
elseif (is_array($param)){
reset($param);
while (list($cle, $valeur) = each($param)){
if (! $this -> mXmodRewrite){
if (! $ok) {
$urlArg .= '?'.urlencode($cle).'='.urlencode($valeur);
$ok = true;
}
else $urlArg .= '&'.urlencode($cle).'='.urlencode($valeur);
}
else {
if (! $ok) {
$urlArg .= '/'.urlencode($cle).'/'.urlencode($valeur);
$ok = true;
}
else $urlArg .= '/'.urlencode($cle).'/'.urlencode($valeur);
}
}
}
elseif ($param) $this -> ErrorTracker(3, 'The third argument must be a queryString or an array.', 'MxUrl', __FILE__, __LINE__);
//Gestion multi-attributs
if (! ((isset($this -> attribut[$index]))? chop($this -> attribut[$index]): false)) $this -> attribut[$index] = ' href="'.$urlArg.'"';
else {
if (empty($this -> attribut[$this -> attribut[$index]])) $this -> attribut[$this -> attribut[$index]] = ' href="'.$urlArg.'"';
else $this -> attribut[$this -> attribut[$index]] .= ' href="'.$urlArg.'"';
}
}
function MxHidden ($index, $param){
if ($this -> adressSystem == 'relative') $index = $this -> relativePath.'.'.$index;
$end = $this -> outputSystem;
$hidden = '';
if ($this -> mXCacheDelay == 0 && $this -> sessionParameter) $param .= '&'.$this -> sessionParameter;
if (is_string($param)) $param = explode('&',$param);
else $this -> ErrorTracker(3,'The second argument must be a queryString.', 'MxHidden', __FILE__, __LINE__);
if (! empty($param)){
for($i = 0; $i < count($param); $i++){
if ($param[$i]) {
$cle = explode('=', $param[$i]);
$hidden .= '<input type="hidden" name="'.$cle[0].'" value="'.$cle[1].'" '.$end."\n";
}
}
}
if ($this -> mXCacheDelay > 0) $hidden .= '<mx:hiddenSession />';
$this -> hidden[$index] = $hidden;
}
function MxCheckerField($index, $type, $name, $value, $checked = false, $attribut = ''){
if ($this -> adressSystem == 'relative') $index = $this -> relativePath.'.'.$index;
$end = $this -> outputSystem;
$type = strtolower($type);
if ($type != "checkbox" && $type != "radio") $this -> ErrorTracker(2, 'This type (<b>'.$type.'</b>) is unknown for this CheckerField manager.', 'MxCheckerField', __FILE__, __LINE__);
$replace = '<input type="'.$type.'" name="'.$name.'" value="'.$value.'"';
if ( $checked ) $replace .= ' checked="checked"';
if ($attribut) $replace .= ' '.$attribut;
$replace .= ' '.$this -> htmlAtt[$index].$end;
$this -> checker[$index] = $replace;
}
//MX Extender----------------------------------------------------------------------------------------
function AddMxPlugIn($name, $type, $fonction){
if (! $name) $this -> ErrorTracker(2, 'You must give a name to identify the plug-in.', 'AddMxPlugIn',__FILE__, __LINE__);
if (! $type) $this -> ErrorTracker(2, 'The type of the plug-in is necessary to instanciate it.', 'AddMxPlugIn', __FILE__, __LINE__);
if (! $fonction || ! function_exists($fonction)) $this -> ErrorManager(3, 'The method addMxPlugin need the name of a function in third argument.', 'AddMxPlugIn',__FILE__, __LINE__);
if ($this -> ErrorChecker()){
switch ($type){
case 'flag':
for ($i = 0; $i < count($this -> flagArray); $i++){
if ($name == $this -> flagArray[$i]) $this -> ErrorTracker(2, 'This plug-in (<b>'.$name.'</b>) has got the same pattern as the native pattern of a ModeliXe flag.', 'AddMxPlugIn', __FILE__, __LINE__);
}
$this -> flagArray[count($this -> flagArray)] = $name;
break;
case 'attribut':
for ($i = 0; $i < count($this -> attributArray); $i++){
if ($name == $this -> attributArray[$i]) $this -> ErrorTracker(2, 'This plug-in (<b>'.$name.'</b>) has got the same pattern as the native pattern of a ModeliXe attribut.', 'AddMxPlugIn', __FILE__, __LINE__);
}
$this -> attributArray[count($this -> attributArray)] = $name;
break;
default :
$this -> ErrorTracker(2, 'This type of plug-in (<b>'.$type.'</b>) is unrecognized.', 'AddMxPlugIn', __FILE__, __LINE__);
}
}
$this -> $name = array();
$this -> plugInMethods[$name] = $fonction;
}
function SetMxPlugIn($name, $index, $arguments){
if ($this -> adressSystem == 'relative') $index = $this -> relativePath.'.'.$index;
if (isset($arguments) && ! is_array($arguments)) $this -> ErrorTracker(2, 'You must give an array of arguments for the plug-in function.', 'SetMxPlugIn', __FILE__, __LINE__);
else {
$tab = &$this -> $name;
$tab[$index] = call_user_func($this -> plugInMethods[$name], $arguments);
}
}
//MX tools -------------------------------------------------------------------------------------------------------------------
//Vérifie l'existence d'un bloc
function IsMxBloc($index){
if ($this -> adressSystem == 'relative') $index = $this -> relativePath.'.'.$index;
$fat = $this -> father[$index];
if (! $fat && $index != $this -> absolutePath) return false;
else return true;
}
//Vérifie l'existence d'une balise
function IsMxFlag($index, $type){
if ($this -> adressSystem == 'relative') $index = $this -> relativePath.'.'.$index;
$tab = $this -> $type;
if (! isset($tab[$index])) return false;
else return $tab[$index];
}
//Vérifie l'existence d'un attribut
function IsMxAttribut($index){
if ($this -> adressSystem == 'relative') $index = $this -> relativePath.'.'.$index;
if (! isset($this -> attributKey[$index])) return false;
else {
if (preg_match('/;/', $this -> attribut[$index])) return $this -> attribut[$this -> attribut[$index]];
else return $this -> attribut[$index];
}
}
//Retourne tout le contenu d'un bloc
function GetMxBloc($index){
if ($this -> adressSystem == 'relative') $index = $this -> relativePath.'.'.$index;
if ($this -> sheetBuilding[$index]) return $this -> sheetBuilding[$index];
else return $this -> templateContent[$index];
}
//Construction d'une queryString
function GetQueryString($keyString, $null = 1){
$queryString = array();
if (is_array($keyString)){
reset($keyString);
while (list($Akey, $value) = each($keyString)){
if (is_array($value)) {
while (list($k, $v) = each($value)) {
array_push($queryString, urlencode($Akey.'['.$k.']').'='.urlencode($v));
}
}
elseif ($null || strlen($value)) array_push($queryString, urlencode($Akey).'='.urlencode($value));
}
return implode('&',$queryString);
}
else $this -> ErrorTracker(3, 'The argument for this function must be an associative array.', 'GetQueryString', __FILE__, __LINE__);
}
//Adressage simplifié
function WithMxPath($path = '', $origine = ''){
if (! $origine) $origine = $this -> adressSystem;
else {
switch($origine){
case 'relative':
break;
case 'absolute':
break;
default:
$origine = 'relative';
break;
}
}
//Si on ne précise pas de path on retourne au path origine
if (empty($path)){
$this -> relativePath = $this -> absolutePath;
if ($origine == 'absolute') $this -> adressSystem = 'absolute';
elseif ($origine == 'relative') $this -> adressSystem = 'relative';
}
//Sinon, en absolu on se situe dans ce path, en relatif on se situe par rapport au path relatif
if ($path) {
if ($origine == 'relative') {
//On redescend dans la hiérarchie jusqu'au path mentionné
if (($test = explode('../', $path)) && count($test) > 1) {
$path = substr($path, strrpos($path, '/') + 1);
$this -> relativePath = substr($this -> relativePath, 0, strlen($this -> relativePath) - strlen(strstr($this -> relativePath, $path)) - 1);
if (! $this -> relativePath) $this -> ErrorTracker(3, 'This path (<b>'.$path.'</b>) does not exist, ModeliXe can\'t build relativePath.', 'WithMxPath', __FILE__, __LINE__);
}
$this -> relativePath .= '.'.$path;
$this -> adressSystem = 'relative';
}
elseif ($origine == 'absolute') {
$this -> relativePath = $path;
$this -> adressSystem = 'absolute';
}
}
}
//Informations de licence
function AboutModeliXe($out = ''){
$texte = "\nLicence et conditions d'utilisations-----------------------------------------------------------------------------\n";
$texte .= 'ModeliXe '.$this -> mXVersion."\nModeliXe est distribué sous licence LGPL, merci de laisser cette en-tête, gage et garantie de cette licence.\n";
$texte .= "ModeliXe est un moteur de template destiné à être utilisé par des applications écrites en PHP.\n";
$texte .= " \n";
$texte .= "Copyright(c) 26 Juin 2001 - ANDRE Thierry (aka Théo)\n";
$texte .= " \n";
$texte .= "Pour tout renseignements mailez à modelixe@free.fr ou thierry.andre@freesbee.fr\n";
$texte .= "------------------------------------------------------------------------------------------------------------------\n";
if ($out) return $texte;
else print('<pre>'.$texte.'</pre>');
}
//Numéro de version
function GetMxVersion(){
return $this -> mXVersion;
}
//Rafraichissement
function MxRefresh($query = ''){
$this -> MxClearCache('this', $query);
}
function MxRefreshAll() {
$this -> MxClearCache();
}
//Mesure de performances
function GetExecutionTime(){
$time = explode(' ',microtime());
$fin = $time[1] + $time[0];
$this -> ExecutionTime = intval(10000 * ((double)$fin - (double)$this -> debut)) / 10000;
return($this -> ExecutionTime);
}
//MX Parsing Engine------------------------------------------------------------------------------------------------------------
function MxParsing($doc = '', $path = '', $father = ''){
$countPath = Array();
//Initialisation
if (! $path) {
$original = true;
$path = $this -> absolutePath;
}
else $original = false;
$this -> father[$path] = $father;
$this -> IsALoop[$path] = false;
//Parsing des balises de bloc, extraction des sous blocs
$ok = true;
switch ($this -> flagSystem){
case 'xml':
$blocRegexp = '/<mx:bloc(?:[ ]+ref="([^"]+)")?[ ]+id="([^"]+)"[ ]*>/S';
break;
case 'classical':
$blocRegexp = '/{start(?:[ ]+ref="([^"]+)")?[ ]+id="([^"]+)"[ ]*}/S';
break;
}
if (preg_match_all($blocRegexp, $doc, $inclusion)){
for($i = 0; $ok; $i++){
//Extraction des différentes informations extraites par la regex
$id = $inclusion[2][0];
$ref = $inclusion[1][0];
$pattern = $inclusion[0][0];
//Calcul des limites du bloc traité
switch ($this -> flagSystem){
case 'xml':
$regexp = '</mx:bloc id="'.$id.'">';
break;
case 'classical':
$regexp = '{end id="'.$id.'"}';
break;
}
$startOfIntrons = strpos($doc, $pattern) + strlen($pattern);
$endOfIntrons = strpos($doc, $regexp);
$length = $endOfIntrons - $startOfIntrons;
if (! $endOfIntrons) $this -> ErrorTracker(4, 'The end of the "<b>'.$id.'</b>" bloc is not found, this bloc can\'t be generate. Verify that the end of bloc\'s flag exists and has a good form, like this pattern <b>'.htmlentities($regexp).'</b>.', 'MxParsing', __FILE__, __LINE__);
//On teste si le bloc en cours posséde une référence vers un autre template
if (! $ref) $this -> templateContent[$path.'.'.$id] = substr($doc, $startOfIntrons, $length);
else {
if ($this -> mXTemplatePath) $ref = $this -> mXTemplatePath.$ref;
$this -> templateContent[$path.'.'.$id] = $this -> GetMxFile($ref);
}
//Création du pattern du bloc traité
$this -> xPattern['inclusion'][$path.'.'.$id] = '<mx:inclusion id="'.$id.'"/>';
$this -> deleted[$path.'.'.$id] = false;
$this -> replacement[$path.'.'.$id] = false;
//Extraction du contenu du bloc pour reconstruire le bloc en cours
$doc = substr($doc, 0, $startOfIntrons - strlen($pattern)).'<mx:inclusion id="'.$id.'"/>'.substr($doc, $endOfIntrons + strlen($regexp));
$this -> templateContent[$path] = $doc;
//Construction de la référence à ce bloc pour la récursivité
$countPath[$i] = $path.'.'.$id;
//Incrémentation du nbre de fils pour le bloc en cours
if (! empty($this -> son[$path][0])) $compt = $this -> son[$path][0];
else {
$compt = 0;
$this -> son[$path][0] = 0;
}
//Construction de la référence au fils du bloc parsé pour le bloc en cours
$this -> son[$path][++ $compt] = $path.'.'.$id;
$this -> son[$path][0] ++;
//Test de fin de boucle
$ok = preg_match_all($blocRegexp, $doc, $inclusion);
}
}
//Parsing des balises ModeliXe
reset($this -> flagArray);
while (list($Akey, $value) = each($this -> flagArray)){
switch ($this -> flagSystem){
case 'xml':
$regexp = '/<mx:'.$value.'(?:[ ]+(?:ref|info)="(?:[^"]+)")?[ ]+id="([^"]+)"(([^>])*(?=\/>))\/>/S';
break;
case 'classical':
$regexp = '/{'.$value.'(?:[ ]+(?:ref|info)="(?:[^"]+)")?[ ]+id="([^"]+)"[ ]*(?i:htmlAtt\[([^\]]*)\])?}/S';
break;
}
if (preg_match_all($regexp, $doc, $flag)){
for ($i = 0; ; $i++){
if (empty ($flag[0][$i])) break;
//Construction du pattern et des valeurs par défaut de ces balises
$this -> xPattern[$value][$path.'.'.$flag[1][$i]] = $flag[0][$i];
//Modification Guillaume Lelarge compatibilité PHP3
/*<PHP3>
$ref = $this -> $value;
$ref[$path.'.'.$flag[1][$i]] = ' ';
$this -> $value = $ref;
$this -> htmlAtt[$path.'.'.$flag[1][$i]] = $flag[2][$i];
</PHP3>*/
$ref = &$this -> $value;
$ref[$path.'.'.$flag[1][$i]] = ' ';
$this -> htmlAtt[$path.'.'.$flag[1][$i]] = $flag[2][$i];
}
}
}
//Parsing des attributs de ModeliXe
switch ($this -> flagSystem){
case 'xml':
$regexp = '/mXattribut="([^"]{3,})"/Si';
$separateur = ':';
break;
case 'classical':
$regexp = '/{attribut ([^\}]+)}/Si';
$separateur = '=';
break;
}
if (preg_match_all($regexp, $doc, $flag)){
for ($i = 0, $k = 0; ; $i++){
if (empty($flag[0][$i])) break;
$pattern = $flag[0][$i];
$motif = $flag[1][$i];
$k = 0;
//Gestion de plusieurs couples de clé-valeurs dans les attributs
$tabVal = explode(';', $motif);
for ($j = 0; $j < count($tabVal); $j++) {
$tabCle = explode($separateur, trim($tabVal[$j]));
$patternKey[++ $k] = trim($tabCle[0]);
$indexValue[$k] = trim($tabCle[1]);
//Gestion multi-attributs
if (count($tabVal) > 1) {
$this -> attribut[$path.'.'.$indexValue[$k]] = $path.'.'.$indexValue[1].';';
if ($k == 1) $this -> xPattern['attribut'][$path.'.'.$indexValue[1].';'] = $pattern;
}
else {
$this -> attribut[$path.'.'.$indexValue[$k]] = ' ';
$this -> xPattern['attribut'][$path.'.'.$indexValue[$k]] = $pattern;
}
if ($patternKey[$k] != 'url') $this -> attributKey[$path.'.'.$indexValue[$k]] = $patternKey[$k];
}
}
}
for ($i = 0; $i < count($countPath); $i++) $this -> MxParsing($this -> templateContent[$countPath[$i]], $countPath[$i], $path);
}
//MX Compression System ------------------------------------------------------------------------------------------------------------------
//Vérifie si la compression est possible et son type
function MxCheckCompress($file){
if((! $this -> mXcompress) || (! extension_loaded("zlib")) || (headers_sent()) || (strlen($file) / 1000 < 8)) return false;
global $HTTP_SERVER_VARS;
if (strstr($HTTP_SERVER_VARS['HTTP_ACCEPT_ENCODING'], 'x-gzip')) return "x-gzip";
if (strstr($HTTP_SERVER_VARS['HTTP_ACCEPT_ENCODING'], 'gzip')) return "gzip";
return false;
}
//Compression des donnees destinées au navigateur
function MxSetCompress($filecontent){
if (($encoding = $this -> MxCheckCompress($filecontent))){
header('Content-Encoding: '.$encoding);
$gzfilecontent = "\x1f\x8b\x08\x00\x00\x00\x00\x00";
$size = strlen($filecontent);
$crc32 = crc32($filecontent);
$gzfilecontent .= gzcompress($filecontent, 9);
$gzfilecontent = substr($gzfilecontent, 0, strlen($gzfilecontent) - 4);
$gzfilecontent .= pack('V',$crc32);
$gzfilecontent .= pack('V',$size);
return $gzfilecontent;
}
else return $filecontent;
}
//MX Cache system ------------------------------------------------------------------------------------------------------------------
//Retourne une clé unique pour les arguments en POST et GET différents des paramètres de session
function GetMD5UrlKey($query = ''){
global $HTTP_POST_VARS, $HTTP_GET_VARS;
if (! $query) $get = $HTTP_GET_VARS;
else $get = $query;
if (! $query) $post = $HTTP_POST_VARS;
else $post = $query;
//Suppression des paramètres de session en GET
$chaine = '';
$this -> DeleteSessionKey($chaine, $get);
//Suppression des paramètres de session en POST
$this -> DeleteSessionKey($chaine, $post);
return (md5($chaine));
}
function DeleteSessionKey(&$chaine, $httpvar){
$param = explode('&', $this -> sessionParameter);
//Tri des tableaux pour les avoir dans le même ordre
asort($httpvar);
asort($param);
//pr est un marqueur pour éviter de parcourir toutes les valeurs des param de session si ceux-ci ont déja été tous supprimés
$pr = 0;
//suppression des paramètres de session(get ou post)
for (reset($httpvar); $cle = key($httpvar); next($httpvar)){
$ok = false;
$compt = count($param);
for ($i = 0; $i < $compt && ($pr != $compt); $i++){
if (($cleU = explode('=', $param[$i])) && $cleU[0] == $cle) {
$ok = true;
$pr ++;
break;
}
}
if (! $ok) $chaine .= $cle.'='.$httpvar[$cle];
}
}
//Vidage du cache
function MxClearCache($fich = '', $query = ''){
if (! $open = @opendir($this -> mXCachePath)) $this -> ErrorTracker(3, 'Can\'t open cache directory (<b>'.$this -> mXCachePath.'</b>) to clear old files.', 'MxClearCache', __FILE__, __LINE__);
else {
while ($fichier = @readdir($open)){
if ($fichier != '.' && $fichier != '..'){
if (! $fich){
if (($currentTime = filemtime($this -> mXCachePath.$fichier)) && time() - $currentTime > $this -> mXCacheDelay) {
if (! @unlink($this -> mXCachePath.$fichier)) $this -> ErrorTracker(3, 'Can\'t unlink this file "<b>'.$fichier.'</b>" in cache directory.', 'MxClearCache', __FILE__, __LINE__);
}
}
else {
//Supprime spécifiquement le fichier du template en cours
$ana = explode('~', $fichier);
if ($ana[1] == $this -> template) {
//Gestion des suppressions spécifiques à une queryString
if ($query && $this -> GetMD5UrlKey($query) == $ana[0]){
if (! @unlink($this -> mXCachePath.$fichier)) $this -> ErrorTracker(3, 'Can\'t unlink this file "<b>'.$fichier.'</b>" in cache directory.', 'MxClearCache', __FILE__, __LINE__);
}
elseif (! @unlink($this -> mXCachePath.$fichier)) $this -> ErrorTracker(3, 'Can\'t unlink this file "<b>'.$fichier.'</b>" in cache directory.', 'MxClearCache', __FILE__, __LINE__);
}
}
}
}
@closedir($open);
}
}
//Initialisation du cache
function MxSetCache($filecontent) {
$this -> MxClearCache('this');
if (! $cache = fopen($this -> mXCachePath.$this -> mXUrlKey.'~'.$this -> template, 'w')) $this -> ErrorTracker(4, 'Can\'t open in writing the cache file on "<b>'.$this -> mXCachePath.'/'.$this -> template.'</b>" path.', 'MxSetCache', __FILE__, __LINE__);
//Sauvegarde du contenu
if ($this -> ErrorChecker()) {
if (! $write = fputs($cache, $filecontent)) $this -> ErrorTracker(5, 'Can\'t wite the cache file on "<b>'.$this -> mXCachePath.$this -> mXUrlKey.'~'.$this -> template.'</b>" path.', 'MxSetCache', __FILE__, __LINE__);
@fclose($cache);
}
}
//Retourne le fichier de cache
function MxGetCache() {
$cache_file = $this -> mXCachePath.$this -> mXUrlKey.'~'.$this -> template;
if (! $open = @fopen($cache_file, 'rb')) $this -> ErrorTracker(5, 'Can\'t open the cache file on "<b>'.$cache_file.'</b>" path.', 'MxGetCache');
if (! $read = @fread($open, filesize($cache_file))) $this -> ErrorTracker(5, 'Can\'t read the cache file on "<b>'.$cache_file.'</b>" path.', 'MxGetCache', __FILE__, __LINE__);
@fclose($open);
//Parsing des paramètres de sessions
$read = $this -> MxSessionParameterParsing($read);
//Si on cherche à mesurer les performances de ModeliXe
if ($this -> performanceTracer) {
$read = str_replace('<mx:performanceTracer />', $this -> GetExecutionTime().' [cache]', $read);
}
//Si il y a une gestion de la compression, envoie des en-têtes correspondantes
$this -> ErrorChecker();
if ($this -> mXoutput) return $read;
else print($this -> MxSetCompress($read));
die();
}
//Teste si le fichier de cache existe et son échéance
function MxCheckCache() {
$cache_file = $this -> mXCachePath.$this -> mXUrlKey.'~'.$this -> template;
if (@is_file($cache_file)){
if (($currentTime = filemtime($cache_file)) && (((time() - $currentTime) < $this -> mXCacheDelay && filemtime($this -> mXTemplatePath.$this -> template) < $currentTime))) return true;
}
else return false;
}
//MX Template Fusion Engine --------------------------------------------------------------------------------------------------
function MxSessionParameterParsing($content) {
$hidden = '';
$param = $this -> sessionParameter;
if ($param){
$content = str_replace('<mx:session />', $param, $content);
$param = explode('&', $this -> sessionParameter);
for($i = 0; $i < count($param); $i++){
if ($param[$i]) {
$cle = explode('=', $param[$i]);
$hidden .= '<input type="hidden" name="'.$cle[0].'" value="'.$cle[1].'" />'."\n";
}
}
$content = str_replace('<mx:hiddenSession />', $hidden, $content);
}
return $content;
}
//Remplace le contenu des templates passés en arguments
function MxReplace($path){
if (! empty($this -> sheetBuilding[$path])) $cible = $this -> sheetBuilding[$path];
else $cible = $this -> templateContent[$path];
//Remplacement de l'ensemble des attributs ModeliXe par les valeurs qui ont été instanciées ou leurs valeurs par défaut
reset($this -> attributArray);
while (list($cle, $Fkey) = each($this -> attributArray)){
$Farray = &$this -> $Fkey;
if (is_array($Farray)){
reset($Farray);
while (list($Pkey, $value) = each($Farray)){
if ($path == substr($Pkey, 0, strrpos($Pkey, '.'))) {
if (isset($this -> xPattern[$Fkey][$Pkey])){
$pattern = $this -> xPattern[$Fkey][$Pkey];
$cible = str_replace($pattern, $value, $cible);
unset($Farray[$Pkey]);
}
}
}
}
}
//Remplacement de l'ensemble des balises ModeliXe par les valeurs qui ont été instanciées ou leurs valeurs par défaut
reset($this -> flagArray);
while (list($cle, $Fkey) = each($this -> flagArray)){
$Farray = &$this -> $Fkey;
if (is_array($Farray)){
reset($Farray);
while (list($Pkey, $value) = each($Farray)){
if ($path == substr($Pkey, 0, strrpos($Pkey, '.'))) {
if (isset($this -> xPattern[$Fkey][$Pkey])){
$pattern = $this -> xPattern[$Fkey][$Pkey];
$cible = str_replace($pattern, $value, $cible);
unset($Farray[$Pkey]);
}
}
}
}
}
return $cible;
}
//Construit les blocs et associe les blocs fils aux blocs parents
function MxBlocBuilder($path = ''){
$ordre = array();
$hierarchie = 1;
if (! $path) $path = $this -> absolutePath;
$chemin = $path;
//Classement de tout les fils de path du plus proche au plus lointain
$base = count(explode('.', $path));
$k = 1;
$l = 1;
$j = 1;
for (; ;){
//Si il existe un fils on le prend
if (! empty($this -> son[$chemin][$j])) $fils = $this -> son[$chemin][$j];
else $fils = '';
//Si il existe on considère le dernier enregistrement trouvé précédant celui-ci
if (! empty($ordre[$hierarchie])) $ancien = $ordre[$hierarchie][count($ordre[$hierarchie])];
else $ancien = false;
if ($fils == $ancien) break;
//Si il n'y a plus de fils, on passe au noeud suivant
if (empty($fils)) {
$j = 1;
if (! empty($ordre[$k][$l])) {
$chemin = $ordre[$k][$l];
$l ++;
}
else {
$l = 1;
$k ++;
if (! empty($ordre[$k][$l])) $chemin = $ordre[$k][$l ++];
else break;
}
}
else {
$j ++;
//Si le fils n'a pas été détruit on le considére
if ($this -> templateContent[$fils]) {
//hiérarchie compte le nombre de blocs à partir du bloc de base
$hierarchie = count(explode('.', $fils)) - $base;
if (empty($ordre[$hierarchie])) $ordre[$hierarchie] = array();
$ordre[$hierarchie][count($ordre[$hierarchie]) + 1] = $fils;
}
}
}
//Insertion des fils les plus lointains dans les fils les plus proches jusqu'au path
for ($i = count($ordre); $i > 0; $i --){
for ($j = 1; $j <= count($ordre[$i]); $j++){
$fils = $ordre[$i][$j];
$pattern = $this -> xPattern['inclusion'][$fils];
$pere = $this -> father[$ordre[$i][$j]];
//Insertion du bloc fils dans le père
if ($pere == $path && $this -> IsALoop[$path]) {
if ($this -> IsALoop[$fils]) {
if ($this -> deleted[$fils]) {
$rem = ' ';
$this -> deleted[$fils] = false;
}
else $rem = $this -> loop[$fils];
$this -> loop[$pere] = str_replace($pattern, $rem, $this -> loop[$pere]);
$this -> loop[$fils] = '';
}
else {
if ($this -> deleted[$fils]) {
$rem = ' ';
$this -> deleted[$fils] = false;
}
else $rem = $this -> MxReplace($fils);
$this -> loop[$pere] = str_replace($pattern, $rem, $this -> loop[$pere]);
$this -> sheetBuilding[$fils] = '';
}
}
else {
if (! empty($this -> sheetBuilding[$pere])) $source = $this -> sheetBuilding[$pere];
else $source = $this -> templateContent[$pere];
if ($this -> IsALoop[$fils]) {
if ($this -> deleted[$fils]) {
$rem = ' ';
$this -> deleted[$fils] = false;
}
else $rem = $this -> loop[$fils];
$this -> sheetBuilding[$pere] = str_replace($pattern, $rem, $source);
$this -> loop[$fils] = '';
}
else {
if ($this -> deleted[$fils]) {
$rem = ' ';
$this -> deleted[$fils] = false;
}
else $rem = $this -> MxReplace($fils);
$this -> sheetBuilding[$pere] = str_replace($pattern, $rem, $source);
$this -> sheetBuilding[$fils] = '';
}
}
}
}
}
//Associe les boucles
function MxLoopBuilder($path = ''){
if (! $path) $path = $this -> absolutePath;
$father = $this -> father[$path];
$pattern = $this -> xPattern['inclusion'][$path];
//On saute les blocs détruits
if ($pattern){
$this -> IsALoop[$path] = true;
if (empty($this -> loop[$path])) $this -> loop[$path] = '';
//Gestion des blocs remplacés temporairement
if ($this -> replacement[$path]) {
$this -> loop[$path] .= $this -> MxReplace($path);
$this -> replacement[$path] = false;
$this -> sheetBuilding[$path] = '';
}
//Gestion des boucles classiques
else {
$this -> sheetBuilding[$path] = '';
if (empty($this -> loop[$path])) $this -> loop[$path] = '';
$this -> loop[$path] .= $this -> MxReplace($path);
}
}
//Insertion des fils de $path dans $path
$this -> MxBlocBuilder($path);
}
//Mx Output -------------------------------------------------------------------------------------------------------------------
//Sortie du fichier HTML généré
function MxWrite ($out = ''){
if (! $this -> mXsetting) $this -> ErrorTracker(5, 'You d\'ont intialize ModeliXe with setModeliXe method, there is no data to write.', 'MxWrite', __FILE__, __LINE__);
//Assemblage de l'ensemble des blocs fils
$this -> MxBlocBuilder();
if ($this -> mXsignature) $entete = '<!--[ModeliXe '.$this -> mXVersion.'] -- '.(($this -> isTemplateFile)? '[TemplateFile : '.$this -> mXTemplatePath.$this -> template.']' : '[Template : '.$this -> template.']').' -- [date '.date('j/m/Y H:i:s')."]-->\n";
else $entete = '';
if ($this -> ErrorChecker()) {
$filecontent = (($entete)? str_replace('<head>', '<head>'."\n".$entete,$filecontent = $this -> MxReplace($this -> absolutePath)) : $filecontent = $this -> MxReplace($this -> absolutePath));
//Remplacement des balises de paramètres
if ($this -> mXParameterFile) $filecontent = $this -> GetParameterParsing($filecontent);
//Mise en cache de la page générée sans les paramètres de sessions
if ($this -> mXCacheDelay > 0) {
$this -> MxSetCache($filecontent);
//Parsing des paramètres de sessions
$filecontent = $this -> MxSessionParameterParsing($filecontent);
}
//Si on cherche à mesurer les performances de ModeliXe
if ($this -> performanceTracer) {
$filecontent = str_replace('<mx:performanceTracer />', $this -> GetExecutionTime(), $filecontent);
}
if ($this -> mXoutput) return $filecontent;
else print($this -> MxSetCompress($filecontent));
}
}
}
?> |
Stumble It!
Bookmark in del.icio.us
Download
