Namespaces

Classes

Interfaces

Exceptions

Functions

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 (https://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: */
19: defined('XOOPS_ROOT_PATH') || exit('Restricted access');
20:
21: include_once XOOPS_ROOT_PATH . '/class/xml/saxparser.php';
22: include_once XOOPS_ROOT_PATH . '/class/xml/xmltaghandler.php';
23:
24: /**
25: * Class XoopsThemeSetParser
26: */
27: class 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: */
146: class 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: */
182: class 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: */
220: class 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: */
259: class 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: */
295: class 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: */
334: class 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: */
370: class 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: */
406: class 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: */
445: class 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: */
484: class 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: */
521: class 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: */
557: class 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:
API documentation generated by ApiGen v7.0.0-alpha.6