1<?php
2/**
3 * XOOPS Utilities
4 *
5 * You may not change or alter any portion of this comment or credits
6 * of supporting developers from this source code or any supporting source code
7 * which is considered copyrighted (c) material of the original comment or credit authors.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
11 *
12 * @copyright       (c) 2000-2016 XOOPS Project (www.xoops.org)
13 * @license             GNU GPL 2 (http://www.gnu.org/licenses/gpl-2.0.html)
14 * @package             class
15 * @subpackage          utility
16 * @since               1.0.0
17 * @author              Author: Kazumi Ono (AKA onokazu)
18 */
19defined('XOOPS_ROOT_PATH') || exit('Restricted access');
20
21include_once XOOPS_ROOT_PATH . '/class/xml/saxparser.php';
22include_once XOOPS_ROOT_PATH . '/class/xml/xmltaghandler.php';
23
24/**
25 * Class XoopsThemeSetParser
26 */
27class XoopsThemeSetParser extends SaxParser
28{
29    public $tempArr       = array();
30    public $themeSetData  = array();
31    public $imagesData    = array();
32    public $templatesData = array();
33
34    /**
35     * @param $input
36     */
37    public function __construct(&$input)
38    {
39        parent::__construct($input);
40        $this->addTagHandler(new ThemeSetThemeNameHandler());
41        $this->addTagHandler(new ThemeSetDateCreatedHandler());
42        $this->addTagHandler(new ThemeSetAuthorHandler());
43        $this->addTagHandler(new ThemeSetDescriptionHandler());
44        $this->addTagHandler(new ThemeSetGeneratorHandler());
45        $this->addTagHandler(new ThemeSetNameHandler());
46        $this->addTagHandler(new ThemeSetEmailHandler());
47        $this->addTagHandler(new ThemeSetLinkHandler());
48        $this->addTagHandler(new ThemeSetTemplateHandler());
49        $this->addTagHandler(new ThemeSetImageHandler());
50        $this->addTagHandler(new ThemeSetModuleHandler());
51        $this->addTagHandler(new ThemeSetFileTypeHandler());
52        $this->addTagHandler(new ThemeSetTagHandler());
53    }
54
55    /**
56     * @param $name
57     * @param $value
58     */
59    public function setThemeSetData($name, &$value)
60    {
61        $this->themeSetData[$name] = &$value;
62    }
63
64    /**
65     * @param null $name
66     *
67     * @return array|bool
68     */
69    public function &getThemeSetData($name = null)
70    {
71        if (isset($name)) {
72            if (isset($this->themeSetData[$name])) {
73                return $this->themeSetData[$name];
74            }
75
76            return false;
77        }
78
79        return $this->themeSetData;
80    }
81
82    /**
83     * @param $imagearr
84     */
85    public function setImagesData(&$imagearr)
86    {
87        $this->imagesData[] = &$imagearr;
88    }
89
90    /**
91     * @return array
92     */
93    public function &getImagesData()
94    {
95        return $this->imagesData;
96    }
97
98    /**
99     * @param $tplarr
100     */
101    public function setTemplatesData(&$tplarr)
102    {
103        $this->templatesData[] = &$tplarr;
104    }
105
106    /**
107     * @return array
108     */
109    public function &getTemplatesData()
110    {
111        return $this->templatesData;
112    }
113
114    /**
115     * @param        $name
116     * @param        $value
117     * @param string $delim
118     */
119    public function setTempArr($name, &$value, $delim = '')
120    {
121        if (!isset($this->tempArr[$name])) {
122            $this->tempArr[$name] = &$value;
123        } else {
124            $this->tempArr[$name] .= $delim . $value;
125        }
126    }
127
128    /**
129     * @return array
130     */
131    public function getTempArr()
132    {
133        return $this->tempArr;
134    }
135
136    public function resetTempArr()
137    {
138        unset($this->tempArr);
139        $this->tempArr = array();
140    }
141}
142
143/**
144 * Class ThemeSetDateCreatedHandler
145 */
146class ThemeSetDateCreatedHandler extends XmlTagHandler
147{
148    /**
149     * ThemeSetDateCreatedHandler constructor.
150     */
151    public function __construct()
152    {
153    }
154
155    /**
156     * @return string
157     */
158    public function getName()
159    {
160        return 'dateCreated';
161    }
162
163    /**
164     * @param $parser
165     * @param $data
166     */
167    public function handleCharacterData($parser, &$data)
168    {
169        switch ($parser->getParentTag()) {
170            case 'themeset':
171                $parser->setThemeSetData('date', $data);
172                break;
173            default:
174                break;
175        }
176    }
177}
178
179/**
180 * Class ThemeSetAuthorHandler
181 */
182class ThemeSetAuthorHandler extends XmlTagHandler
183{
184    /**
185     * ThemeSetAuthorHandler constructor.
186     */
187    public function __construct()
188    {
189    }
190
191    /**
192     * @return string
193     */
194    public function getName()
195    {
196        return 'author';
197    }
198
199    /**
200     * @param $parser
201     * @param $attributes
202     */
203    public function handleBeginElement($parser, &$attributes)
204    {
205        $parser->resetTempArr();
206    }
207
208    /**
209     * @param $parser
210     */
211    public function handleEndElement($parser)
212    {
213        $parser->setCreditsData($parser->getTempArr());
214    }
215}
216
217/**
218 * Class ThemeSetDescriptionHandler
219 */
220class ThemeSetDescriptionHandler extends XmlTagHandler
221{
222    /**
223     * ThemeSetDescriptionHandler constructor.
224     */
225    public function __construct()
226    {
227    }
228
229    /**
230     * @return string
231     */
232    public function getName()
233    {
234        return 'description';
235    }
236
237    /**
238     * @param $parser
239     * @param $data
240     */
241    public function handleCharacterData($parser, &$data)
242    {
243        switch ($parser->getParentTag()) {
244            case 'template':
245                $parser->setTempArr('description', $data);
246                break;
247            case 'image':
248                $parser->setTempArr('description', $data);
249                break;
250            default:
251                break;
252        }
253    }
254}
255
256/**
257 * Class ThemeSetGeneratorHandler
258 */
259class ThemeSetGeneratorHandler extends XmlTagHandler
260{
261    /**
262     * ThemeSetGeneratorHandler constructor.
263     */
264    public function __construct()
265    {
266    }
267
268    /**
269     * @return string
270     */
271    public function getName()
272    {
273        return 'generator';
274    }
275
276    /**
277     * @param $parser
278     * @param $data
279     */
280    public function handleCharacterData($parser, &$data)
281    {
282        switch ($parser->getParentTag()) {
283            case 'themeset':
284                $parser->setThemeSetData('generator', $data);
285                break;
286            default:
287                break;
288        }
289    }
290}
291
292/**
293 * Class ThemeSetNameHandler
294 */
295class ThemeSetNameHandler extends XmlTagHandler
296{
297    /**
298     * ThemeSetNameHandler constructor.
299     */
300    public function __construct()
301    {
302    }
303
304    /**
305     * @return string
306     */
307    public function getName()
308    {
309        return 'name';
310    }
311
312    /**
313     * @param $parser
314     * @param $data
315     */
316    public function handleCharacterData($parser, &$data)
317    {
318        switch ($parser->getParentTag()) {
319            case 'themeset':
320                $parser->setThemeSetData('name', $data);
321                break;
322            case 'author':
323                $parser->setTempArr('name', $data);
324                break;
325            default:
326                break;
327        }
328    }
329}
330
331/**
332 * Class ThemeSetEmailHandler
333 */
334class ThemeSetEmailHandler extends XmlTagHandler
335{
336    /**
337     * ThemeSetEmailHandler constructor.
338     */
339    public function __construct()
340    {
341    }
342
343    /**
344     * @return string
345     */
346    public function getName()
347    {
348        return 'email';
349    }
350
351    /**
352     * @param $parser
353     * @param $data
354     */
355    public function handleCharacterData($parser, &$data)
356    {
357        switch ($parser->getParentTag()) {
358            case 'author':
359                $parser->setTempArr('email', $data);
360                break;
361            default:
362                break;
363        }
364    }
365}
366
367/**
368 * Class ThemeSetLinkHandler
369 */
370class ThemeSetLinkHandler extends XmlTagHandler
371{
372    /**
373     * ThemeSetLinkHandler constructor.
374     */
375    public function __construct()
376    {
377    }
378
379    /**
380     * @return string
381     */
382    public function getName()
383    {
384        return 'link';
385    }
386
387    /**
388     * @param $parser
389     * @param $data
390     */
391    public function handleCharacterData($parser, &$data)
392    {
393        switch ($parser->getParentTag()) {
394            case 'author':
395                $parser->setTempArr('link', $data);
396                break;
397            default:
398                break;
399        }
400    }
401}
402
403/**
404 * Class ThemeSetTemplateHandler
405 */
406class ThemeSetTemplateHandler extends XmlTagHandler
407{
408    /**
409     * ThemeSetTemplateHandler constructor.
410     */
411    public function __construct()
412    {
413    }
414
415    /**
416     * @return string
417     */
418    public function getName()
419    {
420        return 'template';
421    }
422
423    /**
424     * @param $parser
425     * @param $attributes
426     */
427    public function handleBeginElement($parser, &$attributes)
428    {
429        $parser->resetTempArr();
430        $parser->setTempArr('name', $attributes['name']);
431    }
432
433    /**
434     * @param $parser
435     */
436    public function handleEndElement($parser)
437    {
438        $parser->setTemplatesData($parser->getTempArr());
439    }
440}
441
442/**
443 * Class ThemeSetImageHandler
444 */
445class ThemeSetImageHandler extends XmlTagHandler
446{
447    /**
448     * ThemeSetImageHandler constructor.
449     */
450    public function __construct()
451    {
452    }
453
454    /**
455     * @return string
456     */
457    public function getName()
458    {
459        return 'image';
460    }
461
462    /**
463     * @param $parser
464     * @param $attributes
465     */
466    public function handleBeginElement($parser, &$attributes)
467    {
468        $parser->resetTempArr();
469        $parser->setTempArr('name', $attributes[0]);
470    }
471
472    /**
473     * @param $parser
474     */
475    public function handleEndElement($parser)
476    {
477        $parser->setImagesData($parser->getTempArr());
478    }
479}
480
481/**
482 * Class ThemeSetModuleHandler
483 */
484class ThemeSetModuleHandler extends XmlTagHandler
485{
486    /**
487     * ThemeSetModuleHandler constructor.
488     */
489    public function __construct()
490    {
491    }
492
493    /**
494     * @return string
495     */
496    public function getName()
497    {
498        return 'module';
499    }
500
501    /**
502     * @param $parser
503     * @param $data
504     */
505    public function handleCharacterData($parser, &$data)
506    {
507        switch ($parser->getParentTag()) {
508            case 'template':
509            case 'image':
510                $parser->setTempArr('module', $data);
511                break;
512            default:
513                break;
514        }
515    }
516}
517
518/**
519 * Class ThemeSetFileTypeHandler
520 */
521class ThemeSetFileTypeHandler extends XmlTagHandler
522{
523    /**
524     * ThemeSetFileTypeHandler constructor.
525     */
526    public function __construct()
527    {
528    }
529
530    /**
531     * @return string
532     */
533    public function getName()
534    {
535        return 'fileType';
536    }
537
538    /**
539     * @param $parser
540     * @param $data
541     */
542    public function handleCharacterData($parser, &$data)
543    {
544        switch ($parser->getParentTag()) {
545            case 'template':
546                $parser->setTempArr('type', $data);
547                break;
548            default:
549                break;
550        }
551    }
552}
553
554/**
555 * Class ThemeSetTagHandler
556 */
557class ThemeSetTagHandler extends XmlTagHandler
558{
559    /**
560     * ThemeSetTagHandler constructor.
561     */
562    public function __construct()
563    {
564    }
565
566    /**
567     * @return string
568     */
569    public function getName()
570    {
571        return 'tag';
572    }
573
574    /**
575     * @param $parser
576     * @param $data
577     */
578    public function handleCharacterData($parser, &$data)
579    {
580        switch ($parser->getParentTag()) {
581            case 'image':
582                $parser->setTempArr('tag', $data);
583                break;
584            default:
585                break;
586        }
587    }
588}
589