home *** CD-ROM | disk | FTP | other *** search
/ Cricao de Sites - 650 Layouts Prontos / WebMasters.iso / CMS / xoops-2.0.18.1.exe / xoops-2.0.18.1 / htdocs / class / xml / rss / xmlrss2parser.php < prev   
Encoding:
PHP Script  |  2006-05-27  |  16.0 KB  |  745 lines
  1. <?php
  2. // $Id: xmlrss2parser.php 506 2006-05-26 23:10:37Z 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. if (!defined('XOOPS_ROOT_PATH')) {
  32.     die("XOOPS root path not defined");
  33. }
  34. require_once(XOOPS_ROOT_PATH.'/class/xml/saxparser.php');
  35. require_once(XOOPS_ROOT_PATH.'/class/xml/xmltaghandler.php');
  36.  
  37. class XoopsXmlRss2Parser extends SaxParser
  38. {
  39.     var $_tempArr = array();
  40.     var $_channelData = array();
  41.     var $_imageData = array();
  42.     var $_items = array();
  43.  
  44.     function XoopsXmlRss2Parser(&$input)
  45.     {
  46.         $this->SaxParser($input);
  47.         $this->useUtfEncoding();
  48.         $this->addTagHandler(new RssChannelHandler());
  49.         $this->addTagHandler(new RssTitleHandler());
  50.         $this->addTagHandler(new RssLinkHandler());
  51.         $this->addTagHandler(new RssGeneratorHandler());
  52.         $this->addTagHandler(new RssDescriptionHandler());
  53.         $this->addTagHandler(new RssCopyrightHandler());
  54.         $this->addTagHandler(new RssNameHandler());
  55.         $this->addTagHandler(new RssManagingEditorHandler());
  56.         $this->addTagHandler(new RssLanguageHandler());
  57.         $this->addTagHandler(new RssLastBuildDateHandler());
  58.         $this->addTagHandler(new RssWebMasterHandler());
  59.         $this->addTagHandler(new RssImageHandler());
  60.         $this->addTagHandler(new RssUrlHandler());
  61.         $this->addTagHandler(new RssWidthHandler());
  62.         $this->addTagHandler(new RssHeightHandler());
  63.         $this->addTagHandler(new RssItemHandler());
  64.         $this->addTagHandler(new RssCategoryHandler());
  65.         $this->addTagHandler(new RssPubDateHandler());
  66.         $this->addTagHandler(new RssCommentsHandler());
  67.         $this->addTagHandler(new RssSourceHandler());
  68.         $this->addTagHandler(new RssAuthorHandler());
  69.         $this->addTagHandler(new RssGuidHandler());
  70.         $this->addTagHandler(new RssTextInputHandler());
  71.     }
  72.  
  73.     function setChannelData($name, &$value)
  74.     {
  75.         if (!isset($this->_channelData[$name])) {
  76.             $this->_channelData[$name] =& $value;
  77.         } else {
  78.             $this->_channelData[$name] .= $value;
  79.         }
  80.     }
  81.  
  82.     function &getChannelData($name = null)
  83.     {
  84.         if (isset($name)) {
  85.             if (isset($this->_channelData[$name])) {
  86.                 return $this->_channelData[$name];
  87.             }
  88.             return false;
  89.         }
  90.         return $this->_channelData;
  91.     }
  92.  
  93.     function setImageData($name, &$value)
  94.     {
  95.         $this->_imageData[$name] =& $value;
  96.     }
  97.  
  98.     function &getImageData($name = null)
  99.     {
  100.         if (isset($name)) {
  101.             if (isset($this->_imageData[$name])) {
  102.                 return $this->_imageData[$name];
  103.             }
  104.             $return = false;
  105.             return $return;
  106.         }
  107.         return $this->_imageData;
  108.     }
  109.  
  110.     function setItems(&$itemarr)
  111.     {
  112.         $this->_items[] =& $itemarr;
  113.     }
  114.  
  115.     function &getItems()
  116.     {
  117.         return $this->_items;
  118.     }
  119.  
  120.     function setTempArr($name, &$value, $delim = '')
  121.     {
  122.         if (!isset($this->_tempArr[$name])) {
  123.             $this->_tempArr[$name] =& $value;
  124.         } else {
  125.             $this->_tempArr[$name] .= $delim.$value;
  126.         }
  127.     }
  128.  
  129.     function getTempArr()
  130.     {
  131.         return $this->_tempArr;
  132.     }
  133.  
  134.     function resetTempArr()
  135.     {
  136.         unset($this->_tempArr);
  137.         $this->_tempArr = array();
  138.     }
  139. }
  140.  
  141. class RssChannelHandler extends XmlTagHandler
  142. {
  143.  
  144.     function RssChannelHandler()
  145.     {
  146.  
  147.     }
  148.  
  149.     function getName()
  150.     {
  151.         return 'channel';
  152.     }
  153. }
  154.  
  155. class RssTitleHandler extends XmlTagHandler
  156. {
  157.  
  158.     function RssTitleHandler()
  159.     {
  160.  
  161.     }
  162.  
  163.     function getName()
  164.     {
  165.         return 'title';
  166.     }
  167.  
  168.     function handleCharacterData(&$parser, &$data)
  169.     {
  170.         switch ($parser->getParentTag()) {
  171.         case 'channel':
  172.             $parser->setChannelData('title', $data);
  173.             break;
  174.         case 'image':
  175.             $parser->setImageData('title', $data);
  176.             break;
  177.         case 'item':
  178.         case 'textInput':
  179.             $parser->setTempArr('title', $data);
  180.             break;
  181.         default:
  182.             break;
  183.         }
  184.     }
  185. }
  186.  
  187. class RssLinkHandler extends XmlTagHandler
  188. {
  189.  
  190.     function RssLinkHandler()
  191.     {
  192.  
  193.     }
  194.  
  195.     function getName()
  196.     {
  197.         return 'link';
  198.     }
  199.  
  200.     function handleCharacterData(&$parser, &$data)
  201.     {
  202.         switch ($parser->getParentTag()) {
  203.         case 'channel':
  204.             $parser->setChannelData('link', $data);
  205.             break;
  206.         case 'image':
  207.             $parser->setImageData('link', $data);
  208.             break;
  209.         case 'item':
  210.         case 'textInput':
  211.             $parser->setTempArr('link', $data);
  212.             break;
  213.         default:
  214.             break;
  215.         }
  216.     }
  217. }
  218.  
  219. class RssDescriptionHandler extends XmlTagHandler
  220. {
  221.  
  222.     function RssDescriptionHandler()
  223.     {
  224.  
  225.     }
  226.  
  227.     function getName()
  228.     {
  229.         return 'description';
  230.     }
  231.  
  232.     function handleCharacterData(&$parser, &$data)
  233.     {
  234.         switch ($parser->getParentTag()) {
  235.         case 'channel':
  236.             $parser->setChannelData('description', $data);
  237.             break;
  238.         case 'image':
  239.             $parser->setImageData('description', $data);
  240.             break;
  241.         case 'item':
  242.         case 'textInput':
  243.             $parser->setTempArr('description', $data);
  244.             break;
  245.         default:
  246.             break;
  247.         }
  248.     }
  249. }
  250.  
  251. class RssGeneratorHandler extends XmlTagHandler
  252. {
  253.  
  254.     function RssGeneratorHandler()
  255.     {
  256.  
  257.     }
  258.  
  259.     function getName()
  260.     {
  261.         return 'generator';
  262.     }
  263.  
  264.     function handleCharacterData(&$parser, &$data)
  265.     {
  266.         switch ($parser->getParentTag()) {
  267.         case 'channel':
  268.             $parser->setChannelData('generator', $data);
  269.             break;
  270.         default:
  271.             break;
  272.         }
  273.     }
  274. }
  275.  
  276. class RssCopyrightHandler extends XmlTagHandler
  277. {
  278.  
  279.     function RssCopyrightHandler()
  280.     {
  281.  
  282.     }
  283.  
  284.     function getName()
  285.     {
  286.         return 'copyright';
  287.     }
  288.  
  289.     function handleCharacterData(&$parser, &$data)
  290.     {
  291.         switch ($parser->getParentTag()) {
  292.         case 'channel':
  293.             $parser->setChannelData('copyright', $data);
  294.             break;
  295.         default:
  296.             break;
  297.         }
  298.     }
  299. }
  300.  
  301. class RssNameHandler extends XmlTagHandler
  302. {
  303.  
  304.     function RssNameHandler()
  305.     {
  306.  
  307.     }
  308.  
  309.     function getName()
  310.     {
  311.         return 'name';
  312.     }
  313.  
  314.     function handleCharacterData(&$parser, &$data)
  315.     {
  316.         switch ($parser->getParentTag()) {
  317.         case 'textInput':
  318.             $parser->setTempArr('name', $data);
  319.             break;
  320.         default:
  321.             break;
  322.         }
  323.     }
  324. }
  325.  
  326. class RssManagingEditorHandler extends XmlTagHandler
  327. {
  328.  
  329.     function RssManagingEditorHandler()
  330.     {
  331.  
  332.     }
  333.  
  334.     function getName()
  335.     {
  336.         return 'managingEditor';
  337.     }
  338.  
  339.     function handleCharacterData(&$parser, &$data)
  340.     {
  341.         switch ($parser->getParentTag()) {
  342.         case 'channel':
  343.             $parser->setChannelData('editor', $data);
  344.             break;
  345.         default:
  346.             break;
  347.         }
  348.     }
  349. }
  350.  
  351. class RssLanguageHandler extends XmlTagHandler
  352. {
  353.  
  354.     function RssLanguageHandler()
  355.     {
  356.  
  357.     }
  358.  
  359.     function getName()
  360.     {
  361.         return 'language';
  362.     }
  363.  
  364.     function handleCharacterData(&$parser, &$data)
  365.     {
  366.         switch ($parser->getParentTag()) {
  367.         case 'channel':
  368.             $parser->setChannelData('language', $data);
  369.             break;
  370.         default:
  371.             break;
  372.         }
  373.     }
  374. }
  375.  
  376. class RssWebMasterHandler extends XmlTagHandler
  377. {
  378.  
  379.     function RssWebMasterHandler()
  380.     {
  381.  
  382.     }
  383.  
  384.     function getName()
  385.     {
  386.         return 'webMaster';
  387.     }
  388.  
  389.     function handleCharacterData(&$parser, &$data)
  390.     {
  391.         switch ($parser->getParentTag()) {
  392.         case 'channel':
  393.             $parser->setChannelData('webmaster', $data);
  394.             break;
  395.         default:
  396.             break;
  397.         }
  398.     }
  399. }
  400.  
  401. class RssDocsHandler extends XmlTagHandler
  402. {
  403.  
  404.     function RssDocsHandler()
  405.     {
  406.  
  407.     }
  408.  
  409.     function getName()
  410.     {
  411.         return 'docs';
  412.     }
  413.  
  414.     function handleCharacterData(&$parser, &$data)
  415.     {
  416.         switch ($parser->getParentTag()) {
  417.         case 'channel':
  418.             $parser->setChannelData('docs', $data);
  419.             break;
  420.         default:
  421.             break;
  422.         }
  423.     }
  424. }
  425.  
  426. class RssTtlHandler extends XmlTagHandler
  427. {
  428.  
  429.     function RssTtlHandler()
  430.     {
  431.  
  432.     }
  433.  
  434.     function getName()
  435.     {
  436.         return 'ttl';
  437.     }
  438.  
  439.     function handleCharacterData(&$parser, &$data)
  440.     {
  441.         switch ($parser->getParentTag()) {
  442.         case 'channel':
  443.             $parser->setChannelData('ttl', $data);
  444.             break;
  445.         default:
  446.             break;
  447.         }
  448.     }
  449. }
  450.  
  451. class RssTextInputHandler extends XmlTagHandler
  452. {
  453.  
  454.     function RssWebMasterHandler()
  455.     {
  456.  
  457.     }
  458.  
  459.     function getName()
  460.     {
  461.         return 'textInput';
  462.     }
  463.  
  464.     function handleBeginElement(&$parser, &$attributes)
  465.     {
  466.         $parser->resetTempArr();
  467.     }
  468.  
  469.     function handleEndElement(&$parser)
  470.     {
  471.         $parser->setChannelData('textinput', $parser->getTempArr());
  472.     }
  473. }
  474.  
  475. class RssLastBuildDateHandler extends XmlTagHandler
  476. {
  477.  
  478.     function RssLastBuildDateHandler()
  479.     {
  480.  
  481.     }
  482.  
  483.     function getName()
  484.     {
  485.         return 'lastBuildDate';
  486.     }
  487.  
  488.     function handleCharacterData(&$parser, &$data)
  489.     {
  490.         switch ($parser->getParentTag()) {
  491.         case 'channel':
  492.             $parser->setChannelData('lastbuilddate', $data);
  493.             break;
  494.         default:
  495.             break;
  496.         }
  497.     }
  498. }
  499.  
  500. class RssImageHandler extends XmlTagHandler
  501. {
  502.  
  503.     function RssImageHandler()
  504.     {
  505.     }
  506.  
  507.     function getName()
  508.     {
  509.         return 'image';
  510.     }
  511. }
  512.  
  513. class RssUrlHandler extends XmlTagHandler
  514. {
  515.  
  516.     function RssUrlHandler()
  517.     {
  518.  
  519.     }
  520.  
  521.     function getName()
  522.     {
  523.         return 'url';
  524.     }
  525.  
  526.     function handleCharacterData(&$parser, &$data)
  527.     {
  528.         if ($parser->getParentTag() == 'image') {
  529.             $parser->setImageData('url', $data);
  530.         }
  531.     }
  532. }
  533.  
  534. class RssWidthHandler extends XmlTagHandler
  535. {
  536.  
  537.     function RssWidthHandler()
  538.     {
  539.  
  540.     }
  541.  
  542.     function getName()
  543.     {
  544.         return 'width';
  545.     }
  546.  
  547.     function handleCharacterData(&$parser, &$data)
  548.     {
  549.         if ($parser->getParentTag() == 'image') {
  550.             $parser->setImageData('width', $data);
  551.         }
  552.     }
  553. }
  554.  
  555. class RssHeightHandler extends XmlTagHandler
  556. {
  557.  
  558.     function RssHeightHandler()
  559.     {
  560.     }
  561.  
  562.     function getName()
  563.     {
  564.         return 'height';
  565.     }
  566.  
  567.     function handleCharacterData(&$parser, &$data)
  568.     {
  569.         if ($parser->getParentTag() == 'image') {
  570.             $parser->setImageData('height', $data);
  571.         }
  572.     }
  573. }
  574.  
  575. class RssItemHandler extends XmlTagHandler
  576. {
  577.  
  578.     function RssItemHandler()
  579.     {
  580.  
  581.     }
  582.  
  583.     function getName()
  584.     {
  585.         return 'item';
  586.     }
  587.  
  588.     function handleBeginElement(&$parser, &$attributes)
  589.     {
  590.         $parser->resetTempArr();
  591.     }
  592.  
  593.     function handleEndElement(&$parser)
  594.     {
  595.         $items =& $parser->getTempArr();
  596.         $parser->setItems( $items );
  597.     }
  598. }
  599.  
  600. class RssCategoryHandler extends XmlTagHandler
  601. {
  602.  
  603.     function RssCategoryHandler()
  604.     {
  605.  
  606.     }
  607.  
  608.     function getName()
  609.     {
  610.         return 'category';
  611.     }
  612.  
  613.     function handleCharacterData(&$parser, &$data)
  614.     {
  615.         switch ($parser->getParentTag()) {
  616.         case 'channel':
  617.             $parser->setChannelData('category', $data);
  618.             break;
  619.         case 'item':
  620.             $parser->setTempArr('category', $data, ', ');
  621.         default:
  622.             break;
  623.         }
  624.     }
  625. }
  626.  
  627. class RssCommentsHandler extends XmlTagHandler
  628. {
  629.  
  630.     function RssCommentsHandler()
  631.     {
  632.  
  633.     }
  634.  
  635.     function getName()
  636.     {
  637.         return 'comments';
  638.     }
  639.  
  640.     function handleCharacterData(&$parser, &$data)
  641.     {
  642.         if ($parser->getParentTag() == 'item') {
  643.             $parser->setTempArr('comments', $data);
  644.         }
  645.     }
  646. }
  647.  
  648. class RssPubDateHandler extends XmlTagHandler
  649. {
  650.  
  651.     function RssPubDateHandler()
  652.     {
  653.  
  654.     }
  655.  
  656.     function getName()
  657.     {
  658.         return 'pubDate';
  659.     }
  660.  
  661.     function handleCharacterData(&$parser, &$data)
  662.     {
  663.         switch ($parser->getParentTag()) {
  664.         case 'channel':
  665.             $parser->setChannelData('pubdate', $data);
  666.             break;
  667.         case 'item':
  668.             $parser->setTempArr('pubdate', $data);
  669.             break;
  670.         default:
  671.             break;
  672.         }
  673.     }
  674. }
  675.  
  676. class RssGuidHandler extends XmlTagHandler
  677. {
  678.  
  679.     function RssGuidHandler()
  680.     {
  681.  
  682.     }
  683.  
  684.     function getName()
  685.     {
  686.         return 'guid';
  687.     }
  688.  
  689.     function handleCharacterData(&$parser, &$data)
  690.     {
  691.         if ($parser->getParentTag() == 'item') {
  692.             $parser->setTempArr('guid', $data);
  693.         }
  694.     }
  695. }
  696.  
  697. class RssAuthorHandler extends XmlTagHandler
  698. {
  699.  
  700.     function RssGuidHandler()
  701.     {
  702.  
  703.     }
  704.  
  705.     function getName()
  706.     {
  707.         return 'author';
  708.     }
  709.  
  710.     function handleCharacterData(&$parser, &$data)
  711.     {
  712.         if ($parser->getParentTag() == 'item') {
  713.             $parser->setTempArr('author', $data);
  714.         }
  715.     }
  716. }
  717.  
  718. class RssSourceHandler extends XmlTagHandler
  719. {
  720.  
  721.     function RssSourceHandler()
  722.     {
  723.  
  724.     }
  725.  
  726.     function getName()
  727.     {
  728.         return 'source';
  729.     }
  730.  
  731.     function handleBeginElement(&$parser, &$attributes)
  732.     {
  733.         if ($parser->getParentTag() == 'item') {
  734.             $parser->setTempArr('source_url', $attributes['url']);
  735.         }
  736.     }
  737.  
  738.     function handleCharacterData(&$parser, &$data)
  739.     {
  740.         if ($parser->getParentTag() == 'item') {
  741.             $parser->setTempArr('source', $data);
  742.         }
  743.     }
  744. }
  745. ?>