[Sommaire] [Imprimer]

   1  <?php
   2  // $Id: themesetparser.php 2 2005-11-02 18:23:29Z skalpa $

   3  //  ------------------------------------------------------------------------ //

   4  //                XOOPS - PHP Content Management System                      //

   5  //                    Copyright (c) 2000 XOOPS.org                           //

   6  //                       <http://www.xoops.org/>                             //

   7  //  ------------------------------------------------------------------------ //

   8  //  This program is free software; you can redistribute it and/or modify     //

   9  //  it under the terms of the GNU General Public License as published by     //

  10  //  the Free Software Foundation; either version 2 of the License, or        //

  11  //  (at your option) any later version.                                      //

  12  //                                                                           //

  13  //  You may not change or alter any portion of this comment or credits       //

  14  //  of supporting developers from this source code or any supporting         //

  15  //  source code which is considered copyrighted (c) material of the          //

  16  //  original comment or credit authors.                                      //

  17  //                                                                           //

  18  //  This program is distributed in the hope that it will be useful,          //

  19  //  but WITHOUT ANY WARRANTY; without even the implied warranty of           //

  20  //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            //

  21  //  GNU General Public License for more details.                             //

  22  //                                                                           //

  23  //  You should have received a copy of the GNU General Public License        //

  24  //  along with this program; if not, write to the Free Software              //

  25  //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA //

  26  //  ------------------------------------------------------------------------ //

  27  // Author: Kazumi Ono (AKA onokazu)                                          //

  28  // URL: http://www.myweb.ne.jp/, http://www.xoops.org/, http://jp.xoops.org/ //

  29  // Project: The XOOPS Project                                                //

  30  // ------------------------------------------------------------------------- //

  31  
  32  if (!defined('XOOPS_ROOT_PATH')) {
  33      die("XOOPS root path not defined");
  34  }
  35  include_once XOOPS_ROOT_PATH.'/class/xml/saxparser.php';
  36  include_once XOOPS_ROOT_PATH.'/class/xml/xmltaghandler.php';
  37  
  38  class XoopsThemeSetParser extends SaxParser
  39  {
  40      var $tempArr = array();
  41      var $themeSetData = array();
  42      var $imagesData = array();
  43      var $templatesData = array();
  44  
  45  	function XoopsThemeSetParser(&$input)
  46      {
  47          $this->SaxParser($input);
  48          $this->addTagHandler(new ThemeSetThemeNameHandler());
  49          $this->addTagHandler(new ThemeSetDateCreatedHandler());
  50          $this->addTagHandler(new ThemeSetAuthorHandler());
  51          $this->addTagHandler(new ThemeSetDescriptionHandler());
  52          $this->addTagHandler(new ThemeSetGeneratorHandler());
  53          $this->addTagHandler(new ThemeSetNameHandler());
  54          $this->addTagHandler(new ThemeSetEmailHandler());
  55          $this->addTagHandler(new ThemeSetLinkHandler());
  56          $this->addTagHandler(new ThemeSetTemplateHandler());
  57          $this->addTagHandler(new ThemeSetImageHandler());
  58          $this->addTagHandler(new ThemeSetModuleHandler());
  59          $this->addTagHandler(new ThemeSetFileTypeHandler());
  60          $this->addTagHandler(new ThemeSetTagHandler());
  61      }
  62  
  63  	function setThemeSetData($name, &$value)
  64      {
  65          $this->themeSetData[$name] =& $value;
  66      }
  67  
  68      function &getThemeSetData($name=null)
  69      {
  70          if (isset($name)) {
  71              if (isset($this->themeSetData[$name])) {
  72                  return $this->themeSetData[$name];
  73              }
  74              return false;
  75          }
  76          return $this->themeSetData;
  77      }
  78  
  79  	function setImagesData(&$imagearr)
  80      {
  81          $this->imagesData[] =& $imagearr;
  82      }
  83  
  84      function &getImagesData()
  85      {
  86          return $this->imagesData;
  87      }
  88  
  89  	function setTemplatesData(&$tplarr)
  90      {
  91          $this->templatesData[] =& $tplarr;
  92      }
  93  
  94      function &getTemplatesData()
  95      {
  96          return $this->templatesData;
  97      }
  98  
  99  	function setTempArr($name, &$value, $delim='')
 100      {
 101          if (!isset($this->tempArr[$name])) {
 102              $this->tempArr[$name] =& $value;
 103          } else {
 104              $this->tempArr[$name] .= $delim.$value;
 105          }
 106      }
 107  
 108  	function getTempArr()
 109      {
 110          return $this->tempArr;
 111      }
 112  
 113  	function resetTempArr()
 114      {
 115          unset($this->tempArr);
 116          $this->tempArr = array();
 117      }
 118  }
 119  
 120  
 121  class ThemeSetDateCreatedHandler extends XmlTagHandler
 122  {
 123  
 124  	function ThemeSetDateCreatedHandler()
 125      {
 126  
 127      }
 128  
 129  	function getName()
 130      {
 131          return 'dateCreated';
 132      }
 133  
 134  	function handleCharacterData(&$parser, &$data)
 135      {
 136          switch ($parser->getParentTag()) {
 137          case 'themeset':
 138              $parser->setThemeSetData('date', $data);
 139              break;
 140          default:
 141              break;
 142          }
 143      }
 144  }
 145  
 146  class ThemeSetAuthorHandler extends XmlTagHandler
 147  {
 148  	function ThemeSetAuthorHandler()
 149      {
 150  
 151      }
 152  
 153  	function getName()
 154      {
 155          return 'author';
 156      }
 157  
 158  	function handleBeginElement(&$parser, &$attributes)
 159      {
 160          $parser->resetTempArr();
 161      }
 162  
 163  	function handleEndElement(&$parser)
 164      {
 165          $parser->setCreditsData($parser->getTempArr());
 166      }
 167  }
 168  
 169  class ThemeSetDescriptionHandler extends XmlTagHandler
 170  {
 171  	function ThemeSetDescriptionHandler()
 172      {
 173  
 174      }
 175  
 176  	function getName()
 177      {
 178          return 'description';
 179      }
 180  
 181  	function handleCharacterData(&$parser, &$data)
 182      {
 183          switch ($parser->getParentTag()) {
 184          case 'template':
 185              $parser->setTempArr('description', $data);
 186              break;
 187          case 'image':
 188              $parser->setTempArr('description', $data);
 189              break;
 190          default:
 191              break;
 192          }
 193      }
 194  }
 195  
 196  class ThemeSetGeneratorHandler extends XmlTagHandler
 197  {
 198  	function ThemeSetGeneratorHandler()
 199      {
 200  
 201      }
 202  
 203  	function getName()
 204      {
 205          return 'generator';
 206      }
 207  
 208  	function handleCharacterData(&$parser, &$data)
 209      {
 210          switch ($parser->getParentTag()) {
 211          case 'themeset':
 212              $parser->setThemeSetData('generator', $data);
 213              break;
 214          default:
 215              break;
 216          }
 217      }
 218  }
 219  
 220  class ThemeSetNameHandler extends XmlTagHandler
 221  {
 222  	function ThemeSetNameHandler()
 223      {
 224  
 225      }
 226  
 227  	function getName()
 228      {
 229          return 'name';
 230      }
 231  
 232  	function handleCharacterData(&$parser, &$data)
 233      {
 234          switch ($parser->getParentTag()) {
 235          case 'themeset':
 236              $parser->setThemeSetData('name', $data);
 237              break;
 238          case 'author':
 239              $parser->setTempArr('name', $data);
 240              break;
 241          default:
 242              break;
 243          }
 244      }
 245  }
 246  
 247  class ThemeSetEmailHandler extends XmlTagHandler
 248  {
 249  	function ThemeSetEmailHandler()
 250      {
 251  
 252      }
 253  
 254  	function getName()
 255      {
 256          return 'email';
 257      }
 258  
 259  	function handleCharacterData(&$parser, &$data)
 260      {
 261          switch ($parser->getParentTag()) {
 262          case 'author':
 263              $parser->setTempArr('email', $data);
 264              break;
 265          default:
 266              break;
 267          }
 268      }
 269  }
 270  
 271  class ThemeSetLinkHandler extends XmlTagHandler
 272  {
 273  	function ThemeSetLinkHandler()
 274      {
 275  
 276      }
 277  
 278  	function getName()
 279      {
 280          return 'link';
 281      }
 282  
 283  	function handleCharacterData(&$parser, &$data)
 284      {
 285          switch ($parser->getParentTag()) {
 286          case 'author':
 287              $parser->setTempArr('link', $data);
 288              break;
 289          default:
 290              break;
 291          }
 292      }
 293  }
 294  
 295  class ThemeSetTemplateHandler extends XmlTagHandler
 296  {
 297  	function ThemeSetTemplateHandler()
 298      {
 299  
 300      }
 301  
 302  	function getName()
 303      {
 304          return 'template';
 305      }
 306  
 307  	function handleBeginElement(&$parser, &$attributes)
 308      {
 309          $parser->resetTempArr();
 310          $parser->setTempArr('name', $attributes['name']);
 311      }
 312  
 313  	function handleEndElement(&$parser)
 314      {
 315          $parser->setTemplatesData($parser->getTempArr());
 316      }
 317  }
 318  
 319  class ThemeSetImageHandler extends XmlTagHandler
 320  {
 321  	function ThemeSetImageHandler()
 322      {
 323  
 324      }
 325  
 326  	function getName()
 327      {
 328          return 'image';
 329      }
 330  
 331  	function handleBeginElement(&$parser, &$attributes)
 332      {
 333          $parser->resetTempArr();
 334          $parser->setTempArr('name', $attributes[0]);
 335      }
 336  
 337  	function handleEndElement(&$parser)
 338      {
 339          $parser->setImagesData($parser->getTempArr());
 340      }
 341  }
 342  
 343  class ThemeSetModuleHandler extends XmlTagHandler
 344  {
 345  	function ThemeSetModuleHandler()
 346      {
 347  
 348      }
 349  
 350  	function getName()
 351      {
 352          return 'module';
 353      }
 354  
 355  	function handleCharacterData(&$parser, &$data)
 356      {
 357          switch ($parser->getParentTag()) {
 358          case 'template':
 359          case 'image':
 360              $parser->setTempArr('module', $data);
 361              break;
 362          default:
 363              break;
 364          }
 365      }
 366  }
 367  
 368  class ThemeSetFileTypeHandler extends XmlTagHandler
 369  {
 370  	function ThemeSetFileTypeHandler()
 371      {
 372  
 373      }
 374  
 375  	function getName()
 376      {
 377          return 'fileType';
 378      }
 379  
 380  	function handleCharacterData(&$parser, &$data)
 381      {
 382          switch ($parser->getParentTag()) {
 383          case 'template':
 384              $parser->setTempArr('type', $data);
 385              break;
 386          default:
 387              break;
 388          }
 389      }
 390  }
 391  
 392  class ThemeSetTagHandler extends XmlTagHandler
 393  {
 394  	function ThemeSetTagHandler()
 395      {
 396  
 397      }
 398  
 399  	function getName()
 400      {
 401          return 'tag';
 402      }
 403  
 404  	function handleCharacterData(&$parser, &$data)
 405      {
 406          switch ($parser->getParentTag()) {
 407          case 'image':
 408              $parser->setTempArr('tag', $data);
 409              break;
 410          default:
 411              break;
 412          }
 413      }
 414  }
 415  ?>