Permalink
Branch: master
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
1080 lines (975 sloc) 27.3 KB
<?php
/**
* @package class_XML
* gestion de fichier XML en DOM
* @author laurent Aubourg laurent.aubourg@free.fr
*
* @
*/
class gest_xml {
/**
* Constructeur
*/
function __constructl($in_props = array())
{
while (list($key, $value) = each($in_props)) {
$this -> props[$key] = $value;
}
}
/**
* Retourne la valeur d une propriete de l objet
* @param string $in_prop nom de la propriete que l on souhaite recuperer
* @return mixed $this->props[$in_prop] la valeur de la propriete
*/
function get_prop($in_prop)
{
return(@$this->props[$in_prop]);
}
/**
* remplace les caractères non alphabétiques d'une chaine de caractères
* strin$p_string chaine a nettoyer
* return string
*/
private function clean_string($p_string=''){
return(preg_replace('/[^a-z0-9]/i', 'X', $p_string));
}
// SET_PROP //
function set_prop($prop, $value)
{
$this->props[$prop] = $value;
return(1);
}
// DOCUMENT //
/**
*
* creation d'un nouvel objet dom
*/
function init_xml()
{
$this->clean_doc();
$doc =new DOMDocument('1.0',"UTF-8");
$doc->formatOutput=true;
$this -> set_prop('doc_in', $doc);
$this -> set_prop('doc_mode', 1);
}
/**
*
* DOMDOCUMENT
*
*
*
* chargement d'un fichier xml dans un objet Dom ou simple xml
* @param $mode_retour
* la valeur de $mode_retour permet de specifier le type de l'objet renvoye par la metode :
* 1 ->DOM (defaut)
* 2->SimpleXML
* @param string $abs_fic nom absolu du fichier source
* @return mixed si il n a pas pu ouvrir le fichier
* l'objet dom ou simplexml si ok
* $this->props[('doc_in'] (fichier au format DOM ou SimpleXML
* $this->props[('doc_name'](nom absolu du fichier source)
* $this->props[('doc_mode'](mode du document (1 ->DOM (defaut) 2->SimplXML)
* la valeur retournee est stockee dans le tableau props de l'instance
* elle est consultable via la methode get_prop de l'instance de gest_xml
*/
function open_doc($p_abs_fic,$mode_retour=1)
{
if(!is_string($p_abs_fic)){return;}
$this->clean_doc();
$dom = new domDocument;
$dom->formatOutput=true;
if (is_readable($p_abs_fic))
{
$dom->load($p_abs_fic) ;
$this -> set_prop('doc_name', $p_abs_fic);
$this -> set_prop('doc_mode', $mode_retour);
if($mode_retour ==1)
{
$this -> set_prop('doc_in', $dom);
$dom=$this -> get_prop('doc_in');
return($dom);
}elseif($mode_retour ==2)
{
$simple_xml = simplexml_import_dom($dom);
$this -> set_prop('doc_in', $simple_xml);
return($simple_xml);
}
} else {
$this->erreur=$abs_fic.' fichier non lisible';
return;
}
}
/**
* nettoyage des variables concernat le document dans la table props
* le document est alos supprime de l'objet
*/
function close_doc()
{
unset($this -> props['doc_name']);
unset($this -> props['doc_in']);
unset($this -> props['doc_mode']);
}
/**
*
* DOMDOCUMENT
*
*
*
* chargement d'un fichier xml dans un obet Dom ou simple xml e partir d'une chaine de caractere
* @param int $mode_retour * 1 ->DOM (defaut) 2->SimplXML
* la valeur de $mode_retour permet de specifier le type de l'objet renvoye par la metode :
* @param string $string_doc chaine de caracteres contenant le XML
* @return mixed Simple ou DOM
* $this->props[('doc_mode'](mode du document (1 ->DOM (defaut) 2->SimplXML)
* la valeur retournee est stockee dans le tableau props de l'instance
* elle est consultable via la methode get_prop de l'instance de gest_xml
*/
function load_doc($string_doc,$mode_retour=2)
{
$this->clean_doc();
if($doc=simplexml_load_string(StripSlashes($string_doc)))
{
$this -> set_prop('doc_in',$doc);
$this -> set_prop('doc_mode', 2);
if($mode_retour ==2)
{
return($doc);
}else{
$this->toogle_mode(1);
$this -> set_prop('doc_mode', 1);
return($this-> get_prop('doc_in'));
}
}
}
/**
*
* Retourne le contenu d'un fichier XML
* si $doc='' c'est le $props['doc_in'] qui est utilise
* @param DomDocument $doc
* @return string $doc->saveXml() contenu du fichier XML
*/
function dump_doc($doc = null)
{
if(!isset($doc))
{
if($doc=$this->get_prop('doc_in'))
{
return(@$doc->saveXml());
}
}else{
return($doc->saveXml());
}
}
/**
* suppression du document xml des propietes de l'instance en cours
* nettoyage des variables $this-props['doc_in'], $this-props['doc_mode'], $this->name['doc_mode']
*
*/
function clean_doc()
{
$this->set_prop('doc_in','');
$this -> set_prop('doc_name', '');
$this -> set_prop('doc_mode', '');
}
/**
* sauvegarde du document en cours
* @param string $this->get_prop('doc_in')
* @return integer $size nombre d'octets ecrit ou 0 si le source ou le nom du fichier sont vides
*/
function save_doc()
{
// $this->toogle_mode(1) ;
if( $doc=$this->get_prop('doc_in')and $this->get_prop('doc_name'))
{
$doc->formatOutput=true;
return($size=$doc->save($this->get_prop('doc_name'))) ;
}else{
return(0);
}
}
/*
*
* converti un document SimpleXML en Document DOM et met e jour les valeurs du tableau props
* Attention : modifie le contenu de props (doc_in et doc_mode)
*/
private function simple_to_dom()
{
$dom = new domDocument;
$doc=$this->get_prop('doc_in');
$dom_string=$doc->asxml();
$dom->loadXML($dom_string) ;
$this -> set_prop('doc_mode', 1);
$this -> set_prop('doc_in', $dom);
}
/*
* converti un document DOM en Document SIMPLXML et met e jour les valeurs du tableau props
* Attention : modifie le contenu de props (doc_in et doc_mode)
*/
private function DOM_to_simple()
{
$dom=$this->get_prop('doc_in');
$simple=simplexml_import_dom($dom);
$this -> set_prop('doc_mode', 2);
$this -> set_prop('doc_in', $simple);
}
/*
* bascule le document de dom vers simplexml ou inversement
* @param= integer $mod type de document desire 1->DOM 2->simpleXML
*/
private function toogle_mode($mod)
{
//echo($this -> get_prop('doc_mode')." -- ".$mod);
if($this -> get_prop('doc_mode')==1 and $mod==2)
{
$this->DOM_to_simple();
}elseif($this -> get_prop('doc_mode')==2 and $mod==1){
$this->simple_to_dom();
}
}
// ELEMENTS RECUPERATIOB //
/**
* recupere un element le document doit avoir prealablement ete ouvert avec open_doc()
* @param string $nom_elem nom de l'element recherche si vide renvoit tous les elements
* @return tableau de DOMnode
*/
function DOM_get_element($nom_elem="*")
{
$this->toogle_mode(1) ;
$doc=$this->get_prop('doc_in');
$tb_node= array();
$list_node=$doc->getElementsByTagName($nom_elem);
for($i=0;$i<$list_node->length ;$i++)
{
$tb_node[]=$list_node->item($i) ;
}
return($tb_node);
}
function DOM_get_elementById($id_elem)
{
$this->toogle_mode(1) ;
$doc=$this->get_prop('doc_in');
$node=$doc->get_element_by_id( $id_elem);
return($node[0]);
}
/**
* recupere l'element racine du document
* @return objet DOMnode root
*/
function DOM_get_root()
{
$this->toogle_mode(1) ;
$all_elem=$this->DOM_get_element("*") ;
$root=$all_elem[0];
return($root);
}
/**
* recupere le contenu du noeud passe en parametre
* @param DOMnode $elem
* @return string $elem->nodeValue
*/
function DOM_get_content_node($elem)
{
$this->toogle_mode(1) ;
return(utf8_decode($elem->nodeValue));
}
/**
*
* ELEMENT CONTENU
*
/**
* Nom DE L'ELEMENT depuis un node DOM
* retoune le nom de l'element passe en parametre
** @param objet DOM $elem element
** @return string content contenu de l'element
**/
function DOM_get_node_name($elem)
{
if($elem->nodeType==1)
{
return($elem->nodeName);
}
}
/**
* retourne un tableau des noeuds freres
** @param objet DOM $elem element
** @return array $tb_freres tableau des noeuds freres
**/
function DOM_get_node_sibling($elem)
{
$node_parent=$this->DOM_get_parent_node($elem);
$tb_enf_parent=$this->DOM_get_node_children($node_parent->nodeName);
for($i=0;$i<count($tb_enf_parent);$i++)
{
if($tb_enf_parent[$i]->getattribute('id_elem')!=$elem->getattribute('id_elem'))
{
$tb_freres[]=$tb_enf_parent[$i];
}
}
return($tb_freres);
}
/**
* recupere le dernier enfant d'un noeud
* @param domNODE $node noeud dont on souhaite recuperer le dernier enfant
* @return DOMnode $last_node noeud du dernier enfant
*/
function DOM_get_last_child($node)
{
$last_node=$this->lastChild;
return($last_node);
}
/**
* renvoie le premier enfant d'un noeud
* @param domNODE $node noeud dont on souhaite recuperer le premier enfant
* @return DOMnode $first_node noeud du premier enfant
*/
function DOM_get_first_child($node)
{
$first_node=$node->firstChild;
return($first_node);
}
/**
* recupere le prochain frere d'un noeud
* @param domNODE $node noeud dont on souhaite recuperer le prochain frere
* @return DOMnode $next_sibling noeud du prochain frere
*/
function DOM_get_next_sibling($node)
{
$next_sibling=$node->nextSibling;
return($next_sibling);
}
/**
* recupere le precedent frere d'un noeud
* @param domNODE $node noeud dont on souhaite recuperer le precedent frere
* @return DOMnode $previous_sibling noeud du prochain frere
*/
function DOM_get_prev_sibling($node)
{
$previous_sibling=$node->previousSibling ;
return($previous_sibling);
}
/**
* retourne le noeud parent de L'ELEMENT passe en parametre
** @param $elem element
** @return objet DOM $parent
**/
function DOM_get_parent_node($elem)
{
$this->toogle_mode(1) ;
return($elem->parentNode);
}
/**
* enfants DE L'ELEMENT
* retoune un tableau contenant les noeuds enfants de l'element
* @param string $nom_elem nom de l'element
* @return array $nodes_child contenant les nodes enfants de l'element
*/
function DOM_get_node_children($nom_elem)
{
$this->toogle_mode(1) ;
$nodes=$this->DOM_get_element($nom_elem);
$node=$nodes[0];
$enfants=$node->childNodes;
for($i=0;$i<$enfants->length ;$i++)
{
$nodes_child[]=$enfants->item($i) ;
}
return($nodes_child);
}
/**
*
*
*
* enfants DE L'ELEMENT pass� en argument
* retoune un tableau contenant les noeuds enfants de l'�l�ment $node
* @param DOMNODE $nde �l�ment parent
* @return array $nodes_child contenant les nodes enfants de l'�l�ment
*/
function DOM_get_node_tab_children($node)
{
$this->toogle_mode(1) ;
$enfants=$node->childNodes;
for($i=0;$i<$enfants->length ;$i++)
{
$nodes_child[]=$enfants->item($i) ;
}
return($nodes_child);
}
/**
* cree un ensemble de noeuds enfants e l'element passes en parametre
* @param array() $nom_enf
* @param array() $attrib_enf
* @param array() $content_enf
* @param array() $noeud_parent
*/
function DOM_add_nodes_chidren($nom_enf = array(), $attrib_enf= array(), $content_enf=array(),$content_format=array(), $noeud_parent='')
{
if ($noeud_parent == ''){return;}
if (count($nom_enf) > 0) {
for($e = 0;$e < count($nom_enf);$e++) {
$node[$e] = $this ->DOM_add_node($noeud_parent, $nom_enf[$e]);
if(count($attrib_enf)>$e){
if (count($attrib_enf[$e]) > 0) {
if(is_array($attrib_enf[$e])){
$this ->DOM_add_several_arguments_to_node($attrib_enf[$e], $node[$e]);
}
}
}
if (count($content_enf)>$e) {
if (count($content_format) > $e) {
if($content_format[$e] == 'CData'){
$this->DOM_add_CDATA($node[$e],$content_enf[$e]);
}else{
$content = utf8_encode($content_enf[$e]);
$this -> DOM_make_content($node[$e], $content);
}
}else{
$content = utf8_encode($content_enf[$e]);
$this -> DOM_make_content($node[$e], $content);
}
}
}
}
return ($node);
}
/**
*
* ATTRIBUTS DE L'ELEMENT
* retourne tous les attributs d'un element dans une table
* @param object DOMnode $node element dont on veut recuperer les attributs
* @return array() $tb_att tableau nom/valleur des attributs
**/
function DOM_get_node_attributs($node)
{
$this->toogle_mode(1) ;
$list_node_att=$node->attributes;
for($i=0;$i<$list_node_att->length ;$i++)
{
$node_att=$list_node_att->item($i) ;
$tb_att[$node_att->nodeName]=$node_att->nodeValue;
}
return($tb_att);
}
/***
* *
* retourne la valeur de l'attribut passe en parametre
* @param object DOMnode $node element dont on veut recuperer l'attributs
* @param string $name_att nom de l'attibut dont on souhita recuperer la valeur
* @return string $attrib valeur de l'attribut ou 0 en cas d'echec en lecture de this->get_prop('doc_in')
**/
function DOM_get_val_attributs_by_name($node,$name_att)
{
if($node->nodeType!=1){return ('');};
if($this->get_prop('doc_in')!='')
{
$this->toogle_mode(1) ;
return($node->getattribute($name_att));
}else{
return;
}
}
/**
*
* Type DE L'ELEMENT depuis un node DOM
* retoune un tableau conenant le type du noeud et la description de ce type de noeud
** @param objet DOM $elem element
** @return array() $retour
**/
function return_type($node)
{
if($node->nodeType==1)
{
$retour['type']=1;
$retour['label']="Le noeud est un element" ;
return($retour);
}elseif($node->nodeType==2)
{
$retour['type']=2;
$retour['label']="Le noeud est un attribut" ;
return($retour);
}elseif($node->nodeType==3)
{
$retour['type']=3;
$retour['label']="Le noeud est un texte";
return($retour);
}elseif($node->nodeType==9)
{
$retour['type']=9;
$retour['label']="Le noeud est un document";
return($retour);
}
}
// XPATH //
/**
*
* retourne un ensemble d’éléments sectionnes par le pattern
*
* @param string $patern pattern XPATH
* @return array() $table table d'objet DOMnode
*/
function get_node_by_Xpath($patern)
{
// print "get_node_by_Xpath($patern)<br>";
$this->toogle_mode(1) ;
$doc=$this->get_prop('doc_in') ;
if (!is_null($doc))
{
$objectXPath = new DOMXPath($doc);
$nodeList = @$objectXPath->query($patern);
$i = 0;
if($nodeList)
{
while ( $node = $nodeList->item($i) )
{
$table[]=$node;
$i++;
}
if(isset($table)){
return($table);
}
}
}
}
/**
*
* retourne un tableau des tableaux associatifs d'attributs
* des differents elements recuperes via la requete XPATH
* @param
* @param string $patern pattern XPATH
* @return array() $table_attrib table de de table d'attributs
*/
function get_node_attributs_by_Xpath ($patern)
{
$table=$this->get_node_by_Xpath($patern);
for($i=0;$i<count($table);$i++)
{
$tb_att=$this->DOM_get_node_attributs($table[$i]);
$tb_attrib[$table[$i]->nodeName]=$tb_att;
}
return($tb_attrib);
}
/**
*
* retourne un tableau des contenus d' éléments sélectionnes par un pattern XPATH
* @param string $patern pattern XPATH
* @return array() $table table contenus de l'element
*/
function get_node_value_by_Xpath($patern)
{
$table=$this->xml_get_node_by_Xpath($patern);
for($i=0;$i<count($table);$i++)
{
$tb_value[]=utf8_decode($table[$i]->nodeValue);
}
return($tb_value);
}
// ELEMENTS CREATION/MODIFICATION //
/**
*
* copie ou colle un element
* @param DOMnode $node element e copier (mod:1) ou element recevant lors du colle (mod:2) (copier par defaut)
* @param integer $mode 1 copier 2 coller
* la copie se fait par clonage du noeud passe en parametre la profondeur de la copie et passee
* en parametre
* methode interne e la classe
*/
private function DOM_fragment($node,$profondeur,$mod=1)
{
$doc=$this->get_prop('doc_in');
if($this->get_prop('doc_frag')!='')
{
$frag=$this->get_prop('doc_frag');
}else
{
$frag=$doc->createDocumentFragment();
}
if($mod==1)
{
$clone=$node->cloneNode($profondeur);
//$this->DOM_add_node_attribut('att1','clone',$clone);
$frag->appendChild ($clone);
$this->set_prop('doc_frag',$frag);
}elseif($mod==2)
{
if(!empty($frag))
{
$new_node=$doc->importNode($frag,1);
return $node->appendChild($new_node);
//print_r($this->DOM_get_node_tab_children($node));
// $node->appendChild ($frag);
}
}
}
/**
*
* copie un element e l'interieur d'un document
* @param DOMnode $node element e copier
* @param integer $profondeur 1: copie egalement les noeuds enfant (par defaut)
* methode interne e la classe
*/
function DOM_copy_node($node,$profondeur=1)
{
$this-> DOM_fragment($node,$profondeur,1);
}
/**
*
* deplace un element d'un noeud vers un autre
* @param DOMnode $node element e deplacer
* @param DOMnode $node element e remplacer
* inverse le noeud destiantion et le noeud node
*/
function DOM_interchange_node($node,$node_dest)
{
$doc=$this->get_prop('doc_in');
$node_ori=$node->cloneNode(1);
$node_cible=$node_dest->cloneNode(1);
$new_ori=$doc->importNode($node_ori,1);
$parent_ori=$this->DOM_get_parent_node($node);
$new_cible=$doc->importNode($node_cible,1);
$parent_cible=$this->DOM_get_parent_node($node_dest);
$parent_ori->replaceChild($new_cible, $node);
$parent_cible->replaceChild($new_ori, $node_dest);
}
/**
* Retourne les attributs d un nœud sous forme de tableau
* @param object Objet noeud en simple xml duquel on souhaite recuperer les attributs
* @return array $tb tableau des valeurs des attributs
*/
function get_array_node_attributs($simple_elem)
{
foreach($simple_elem->attributes() as $key => $val)
{
$tb[$key] =(string)$val;
}
return($tb);
}
/**
*
* remplace un element par un autre
* copie un element e l'interieur d'un document
* @param DOMnode $node element e copier
* @param DOMnode $node element e remplacer
* remplce le noeud destiantion par le noeud node
*/
function DOM_replace_node($node,$node_dest)
{
$doc=$this->get_prop('doc_in');
$node_ori=$node->cloneNode(1);
$new_ori=$doc->importNode($node_ori,1);
$parent_cible=$this->DOM_get_parent_node($node_dest);
$parent_cible->replaceChild($new_ori, $node_dest);
}
/**
*
* copie un eelement d'un autre document
* @param DOMnode $node element a copier
* @param DOMnode $node_dest element destination
* @param integer $profondeur 1: copie egalement es noeuds enfant (par defaut)
* @return DOMnode $new_node le noeud copie dans le document
*/
function DOM_import_element($node,$node_dest,$profondeur=1)
{
$doc=$this->get_prop('doc_in');
$new_node=$doc-> importNode($node,$profondeur);
$this->DOM_add_node_to_target($new_node,$node_dest);
$this->set_prop('doc_in',$doc);
return($new_node);
}
/**
*
* coupe un element
* @param DOMnode $node element a copier
* @param integer $profondeur 1: copie egalement les noeuds enfant (par defaut)
* methode interne e la classe
*/
function DOM_cut_node($node,$profondeur=1)
{
$this-> DOM_fragment($node,$profondeur,1);
$parent_node=$node->parentNode;
$parent_node->removeChild($node);
}
/**
*
* coller des elements . colle le contenu du Documentfragment frag
* sous le noeud passe en parametre
* @param DOMnode $node dest node destainataire du collage
*
*/
function DOM_paste_node($node_dest)
{
$node=$this-> DOM_fragment($node_dest,0,2);
$this-> DOM_clean_fragment();
return $node;
}
/**
*
* vide la variable $props['doc_frag'}
*
*/
private function DOM_clean_fragment()
{
unset($this->props['doc_frag']);
}
/**
*
* Cree un DOMdocument puis ajoute et retourne un nouvel element racine
* @param $nom_elem tagname du nouvel element
* @return DOMnode $root noeud racine du document
*/
function DOM_create_root($nom_elem="root")
{
$this->init_xml();
$doc=$this->get_prop('doc_in');
$root=$this->DOM_get_new_node($this->clean_string($nom_elem));
$doc->appendChild ($root);
return($root);
}
/**
*
* cree et retourne un nouvel element
* @param $nom_elem tagname du nouvel element
* @return DOMnode $elem nouvel element creee
* methode interne e la classe
*/
private function DOM_get_new_node($nom_elem)
{
$this->toogle_mode(1) ;
$doc=$this->get_prop('doc_in');
$elem=$doc->createElement($nom_elem);
return($elem);
}
/**
*
* creee et retourne un nouvel element CDATA
* @param string contenu texte du cdata
* @return DOMCDATASection $cdata
* methode interne e la classe
*/
private function DOM_create_CDATA($contenu)
{
$this->toogle_mode(1) ;
$doc=$this->get_prop('doc_in');
$cdata=$doc->createCDATASection($contenu);
return($cdata);
}
/**
*
* cree et ajoute au noeud en cours un nouvel element CDATA
* @param string contenu texte du cdata
*
*/
function DOM_add_CDATA($node,$contenu)
{
$cdata=$this->DOM_create_CDATA($contenu);
$node->appendChild ($cdata);
}
/**
*
* ajoute et retourne un nouvel element enfant a celui passe en argument
* @param string $nom_elem tagname du nouvel element
* @param DOMnode $node_parent
* @return DOMnode $node_parent element auquel on ajoute les enfants
*/
function DOM_add_node($node_parent,$nom_elem="pas_de_nom")
{
$this->toogle_mode(1) ;
$node=$this->DOM_get_new_node($nom_elem);
if($node_parent)
{
$node_parent->appendChild ($node);
}
return($node);
}
/**
*
* ajoute un element $node au noeud $node_dest
* @param DOMnode $node
* @param DOMnode $node_dest
*/
function DOM_add_node_to_target($node='',$node_dest='')
{
// $this->toogle_mode(1) ;
if($node=='' OR $node_dest==''){return;}
$node_dest->appendChild ($node);
return($node);
}
/**
*
* ajoute un nouvel attribut a l'element passe en argument
* @param string nom_att nom de l'attribut
* @param string val_att valeur de l'attribut
* @param DOMnode $elem element auquel on ajoute l'argument
*/
function DOM_add_node_attribut($nom_att = '',$val_att='',$elem = '')
{
if($nom_att !='' and $val_att !='' and $elem != '')
{
$this->toogle_mode(1) ;
$elem->setattribute ($nom_att, $val_att);
return($elem);
}else{
return(0);
}
}
/**
*
* supprime un element
* @param DOMnode $ode element que l'on souhaite supprimer
*/
function DOM_delete_node($node)
{
$parent_node=$node->parentNode;
$parent_node->removeChild($node);
}
/**
* Creation d attributs multiples
* @param array $table tableau des attributs $table[index][nom_att][val_att]
* @param object DOMnode $noeud Element auquel on doit ajouter les attributs
*/
function DOM_add_several_arguments_to_node($array_arg = array(), $noeud = '')
{
if($noeud == ''){
return;
}
while (list($key, $value) = each($array_arg))
{
$this -> DOM_add_node_attribut($key,utf8_decode($value),$noeud);
}
}
/**
*
* ajoute du contenu e l'element passe en argument
* @param DOMnode $nom_elem element auquel on ajoute du contenu
* @param propriete props['doc_in']
*le fichier doit etre ouvert via la methode open_doc($abs_fic,$mode_retour=1) qui initialise la propriete
* props['doc_in']
*/
function DOM_make_content($node='', $val_content='')
{
if($node == ''){return;}
$this->toogle_mode(1) ;
$doc=$this->get_prop('doc_in');
$val_content = StripSlashes($val_content);
@$child=$this->DOM_get_node_children($node);
for($i=0;$i<count($child);$i++)
{
if($child[$i]->nodeType==3)
{
$this->DOM_delete_node($child[$i]);
}
}
$doc=$this->get_prop('doc_in');
$node_text=$doc->createTextNode (utf8_encode($val_content)) ;
$node->appendChild($node_text);
}
// DIVERS //
/*
* verifie si un noeud a comme ancetre un noeud de nom $nodeName pouvant
* etre precise par sa valeur ou l'un (voir plusieurs de ces attributs
* @param DomNode $node
* @param string $nodename
* @return bolean FALSE/TRUE
*/
function DOM_node_is_content_by($node,$nodeName,$nodeValue='',$tb_att='')
{
$testNode =$node->parentNode;
$test = 1;
while ($test == 1)
{
//si le noeud en cours a le nom recherche
if ($testNode->nodeName==$nodeName)
{
//si la valeur est testee
if($nodeValue)
{
//si la valeur du noeud en cours est identique e la valeur recherchee
if ($testNode->nodeValue==$nodeValue)
{
//si un tableau d'arguments est passe
if(is_array($tb_att))
{
foreach( $tb_att as $nom_att=>$val_att)
{
// si l'argument n'a pas la bonne valeur (ou n'existe pas) la table est videe
if (!$this->DOM_get_val_attributs_by_name($testNode,$nom_att)==$val_att)
{
// $tb_att=array();
}else{
// nom ok valeur ok attributs ok
return (true);
}
}
}else{
// nom ok valeur ok
return (true);
}
}
}else{
//si un tableau d'arguments est passe
if(is_array($tb_att))
{
foreach( $tb_att as $nom_att=>$val_att)
{
// si l'argument n'a pas la bonne valeur (ou n'existe pas) la table est videe
if ($this->DOM_get_val_attributs_by_name($testNode,$nom_att)==$val_att)
{ // nom ok valeur ok attributs ok
return (true);
}else{
$test=0;
break;
}
}
}else{
// nom ok valeur ok
return (true);
}
}
}else{
$testNode = $testNode->parentNode;
}
}
return (false);
}
/**
* fonction de gestion de catalogue
* recherche et inclus dans le document en cours tous les element contenant
* l'argrument fic_xml (sauf l'element racine) , cet argument doit contenir
* comme valeur le path complet du fichier e inclure.
* Le contenu de l'element racine de ce document est alors inclus dans le noeud en cours
*
*/
function DOM_insert_file_content()
{
if($this->get_prop('doc_in'))
{
$n=$this->DOM_get_root();
}
if ($n->hasChildNodes())
{
for ($c = $n->firstChild; $c != null; $c = $c->nextSibling)
{
if($fic_xml=$this->DOM_get_val_attributs_by_name($c,'fic_xml'))
{
$gest=new gest_xml(array());
/* if(!LKS)
{
$fic_xml='lks/fichiers/1/'.$fic_xml;
}else{
$fic_xml='fichiers/1/'.$fic_xml;
}
*/
if($gest->open_doc($fic_xml,1))
{
$node_fic=$gest->DOM_get_root();
$doc=$this->get_prop('doc_in');
$new_node=$doc-> importNode($node_fic,1);
$this->DOM_add_node_to_target($new_node,$c);
unset ($gest);
$this->set_prop('doc_in',$doc);
}
}
}
}
}
// **********************************************************************//
}
?>