OSDN Git Service

Update project date from '2002 - 2009' to '2002 - 2010'.
[nucleus-jp/nucleus-jp-ancient.git] / utf8 / nucleus / libs / skinie.php
1 <?php
2 /*
3  * Nucleus: PHP/MySQL Weblog CMS (http://nucleuscms.org/)
4  * Copyright (C) 2002-2010 The Nucleus Group
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  * (see nucleus/documentation/index.html#license for more info)
11  */
12 /**
13  *      This class contains two classes that can be used for importing and
14  *      exporting Nucleus skins: SKINIMPORT and SKINEXPORT
15  *
16  * @license http://nucleuscms.org/license.txt GNU General Public License
17  * @copyright Copyright (C) 2002-2010 The Nucleus Group
18  * @version $Id$
19  * @version $NucleusJP: skinie.php,v 1.9.2.1 2007/09/05 07:46:30 kimitake Exp $
20  */
21
22 class SKINIMPORT {
23
24         // hardcoded value (see constructor). When 1, interesting info about the
25         // parsing process is sent to the output
26         var $debug;
27
28         // parser/file pointer
29         var $parser;
30         var $fp;
31
32         // which data has been read?
33         var $metaDataRead;
34         var $allRead;
35
36         // extracted data
37         var $skins;
38         var $templates;
39         var $info;
40
41         // to maintain track of where we are inside the XML file
42         var $inXml;
43         var $inData;
44         var $inMeta;
45         var $inSkin;
46         var $inTemplate;
47         var $currentName;
48         var $currentPartName;
49         var $cdata;
50
51
52
53         /**
54          * constructor initializes data structures
55          */
56         function SKINIMPORT() {
57                 // disable magic_quotes_runtime if it's turned on
58                 set_magic_quotes_runtime(0);
59
60                 // debugging mode?
61                 $this->debug = 0;
62
63                 $this->reset();
64
65         }
66
67         function reset() {
68                 if ($this->parser)
69                         xml_parser_free($this->parser);
70
71                 // XML file pointer
72                 $this->fp = 0;
73
74                 // which data has been read?
75                 $this->metaDataRead = 0;
76                 $this->allRead = 0;
77
78                 // to maintain track of where we are inside the XML file
79                 $this->inXml = 0;
80                 $this->inData = 0;
81                 $this->inMeta = 0;
82                 $this->inSkin = 0;
83                 $this->inTemplate = 0;
84                 $this->currentName = '';
85                 $this->currentPartName = '';
86
87                 // character data pile
88                 $this->cdata = '';
89
90                 // list of skinnames and templatenames (will be array of array)
91                 $this->skins = array();
92                 $this->templates = array();
93
94                 // extra info included in the XML files (e.g. installation notes)
95                 $this->info = '';
96
97                 // init XML parser
98                 $this->parser = xml_parser_create();
99                 xml_set_object($this->parser, $this);
100                 xml_set_element_handler($this->parser, 'startElement', 'endElement');
101                 xml_set_character_data_handler($this->parser, 'characterData');
102                 xml_parser_set_option($this->parser, XML_OPTION_CASE_FOLDING, 0);
103
104         }
105
106         /**
107          * Reads an XML file into memory
108          *
109          * @param $filename
110          *              Which file to read
111          * @param $metaOnly
112          *              Set to 1 when only the metadata needs to be read (optional, default 0)
113          */
114         function readFile($filename, $metaOnly = 0) {
115                 // open file
116                 $this->fp = @fopen($filename, 'r');
117                 if (!$this->fp) {
118                         return _SKINIE_ERROR_FAILEDOPEN_FILEURL;
119                 }
120
121                 // here we go!
122                 $this->inXml = 1;
123
124                 $tempbuffer = null;
125
126                 while (!feof($this->fp)) {
127                         $tempbuffer .= fread($this->fp, 4096);
128                 }
129                 fclose($this->fp);
130
131 /*
132         [2004-08-04] dekarma - Took this out since it messes up good XML if it has skins/templates
133                                                    with CDATA sections. need to investigate consequences.
134                                                    see bug [ 999914 ] Import fails (multiple skins in XML/one of them with CDATA)
135
136                 // backwards compatibility with the non-wellformed skinbackup.xml files
137                 // generated by v2/v3 (when CDATA sections were present in skins)
138                 // split up those CDATA sections into multiple ones
139                 $tempbuffer = preg_replace_callback(
140                         "/(<!\[CDATA\[[^]]*?<!\[CDATA\[[^]]*)((?:\]\].*?<!\[CDATA.*?)*)(\]\])(.*\]\])/ms",
141                         create_function(
142                                 '$matches',
143                                 'return $matches[1] . preg_replace("/(\]\])(.*?<!\[CDATA)/ms","]]]]><![CDATA[$2",$matches[2])."]]]]><![CDATA[".$matches[4];'
144                         ),
145                         $tempbuffer
146                 );
147 */
148                 $temp = tmpfile();
149 //              fwrite($temp, $tempbuffer);
150                 if (!function_exists('mb_convert_encoding')) {
151                         fwrite($temp, $tempbuffer);
152                 } else {
153                         if (strtoupper(_CHARSET) == 'ISO-8859-1') {
154                                 fwrite($temp, $tempbuffer);
155                         } else {
156                                 mb_detect_order("ASCII, JIS, SJIS, UTF-8, EUC-JP, ISO-8859-1");
157                                 $temp_encode = mb_detect_encoding($tempbuffer);
158                                 fwrite($temp, mb_convert_encoding($tempbuffer, 'UTF-8', $temp_encode));
159                         }
160                 }
161                 rewind($temp);
162
163                 while ( ($buffer = fread($temp, 4096) ) && (!$metaOnly || ($metaOnly && !$this->metaDataRead))) {
164                         $err = xml_parse( $this->parser, $buffer, feof($temp) );
165                         if (!$err && $this->debug) {
166                                 echo _ERROR . ': ' . xml_error_string(xml_get_error_code($this->parser)) . '<br />';
167                         }
168                 }
169
170                 // all done
171                 $this->inXml = 0;
172                 fclose($temp);
173         }
174
175         /**
176          * Returns the list of skin names
177          */
178         function getSkinNames() {
179                 return array_keys($this->skins);
180         }
181
182         /**
183          * Returns the list of template names
184          */
185         function getTemplateNames() {
186                 return array_keys($this->templates);
187         }
188
189         /**
190          * Returns the extra information included in the XML file
191          */
192         function getInfo() {
193                 return $this->info;
194         }
195
196         /**
197          * Writes the skins and templates to the database
198          *
199          * @param $allowOverwrite
200          *              set to 1 when allowed to overwrite existing skins with the same name
201          *              (default = 0)
202          */
203         function writeToDatabase($allowOverwrite = 0) {
204                 $existingSkins = $this->checkSkinNameClashes();
205                 $existingTemplates = $this->checkTemplateNameClashes();
206
207                 // if not allowed to overwrite, check if any nameclashes exists
208                 if (!$allowOverwrite) {
209                         if ((sizeof($existingSkins) > 0) || (sizeof($existingTemplates) > 0)) {
210                                 return _SKINIE_NAME_CLASHES_DETECTED;
211                         }
212                 }
213
214                 foreach ($this->skins as $skinName => $data) {
215                         // 1. if exists: delete all part data, update desc data
216                         //    if not exists: create desc
217                         if (in_array($skinName, $existingSkins)) {
218                                 $skinObj = SKIN::createFromName($skinName);
219
220                                 // delete all parts of the skin
221                                 $skinObj->deleteAllParts();
222
223                                 // update general info
224                                 $skinObj->updateGeneralInfo(
225                                         $skinName,
226                                         $data['description'],
227                                         $data['type'],
228                                         $data['includeMode'],
229                                         $data['includePrefix']
230                                 );
231                         } else {
232                                 $skinid = SKIN::createNew(
233                                         $skinName,
234                                         $data['description'],
235                                         $data['type'],
236                                         $data['includeMode'],
237                                         $data['includePrefix']
238                                 );
239                                 $skinObj = new SKIN($skinid);
240                         }
241
242                         // 2. add parts
243                         foreach ($data['parts'] as $partName => $partContent) {
244                                 $skinObj->update($partName, $partContent);
245                         }
246                 }
247
248                 foreach ($this->templates as $templateName => $data) {
249                         // 1. if exists: delete all part data, update desc data
250                         //    if not exists: create desc
251                         if (in_array($templateName, $existingTemplates)) {
252                                 $templateObj = TEMPLATE::createFromName($templateName);
253
254                                 // delete all parts of the template
255                                 $templateObj->deleteAllParts();
256
257                                 // update general info
258                                 $templateObj->updateGeneralInfo($templateName, $data['description']);
259                         } else {
260                                 $templateid = TEMPLATE::createNew($templateName, $data['description']);
261                                 $templateObj = new TEMPLATE($templateid);
262                         }
263
264                         // 2. add parts
265                         foreach ($data['parts'] as $partName => $partContent) {
266                                 $templateObj->update($partName, $partContent);
267                         }
268                 }
269
270
271         }
272
273         /**
274           * returns an array of all the skin nameclashes (empty array when no name clashes)
275           */
276         function checkSkinNameClashes() {
277                 $clashes = array();
278
279                 foreach ($this->skins as $skinName => $data) {
280                         if (SKIN::exists($skinName)) {
281                                 array_push($clashes, $skinName);
282                         }
283                 }
284
285                 return $clashes;
286         }
287
288         /**
289           * returns an array of all the template nameclashes
290           * (empty array when no name clashes)
291           */
292         function checkTemplateNameClashes() {
293                 $clashes = array();
294
295                 foreach ($this->templates as $templateName => $data) {
296                         if (TEMPLATE::exists($templateName)) {
297                                 array_push($clashes, $templateName);
298                         }
299                 }
300
301                 return $clashes;
302         }
303
304         /**
305          * Called by XML parser for each new start element encountered
306          */
307         function startElement($parser, $name, $attrs) {
308                 foreach($attrs as $key=>$value) {
309                         $attrs[$key] = htmlspecialchars($value, ENT_QUOTES);
310                 }
311
312                 if ($this->debug) {
313                         echo 'START: ' . htmlspecialchars($name, ENT_QUOTES) . '<br />';
314                 }
315
316                 switch ($name) {
317                         case 'nucleusskin':
318                                 $this->inData = 1;
319                                 break;
320                         case 'meta':
321                                 $this->inMeta = 1;
322                                 break;
323                         case 'info':
324                                 // no action needed
325                                 break;
326                         case 'skin':
327                                 if (!$this->inMeta) {
328                                         $this->inSkin = 1;
329                                         $this->currentName = $attrs['name'];
330                                         $this->skins[$this->currentName]['type'] = $attrs['type'];
331                                         $this->skins[$this->currentName]['includeMode'] = $attrs['includeMode'];
332                                         $this->skins[$this->currentName]['includePrefix'] = $attrs['includePrefix'];
333                                         $this->skins[$this->currentName]['parts'] = array();
334                                 } else {
335                                         $this->skins[$attrs['name']] = array();
336                                         $this->skins[$attrs['name']]['parts'] = array();
337                                 }
338                                 break;
339                         case 'template':
340                                 if (!$this->inMeta) {
341                                         $this->inTemplate = 1;
342                                         $this->currentName = $attrs['name'];
343                                         $this->templates[$this->currentName]['parts'] = array();
344                                 } else {
345                                         $this->templates[$attrs['name']] = array();
346                                         $this->templates[$attrs['name']]['parts'] = array();
347                                 }
348                                 break;
349                         case 'description':
350                                 // no action needed
351                                 break;
352                         case 'part':
353                                 $this->currentPartName = $attrs['name'];
354                                 break;
355                         default:
356                                 echo _SKINIE_SEELEMENT_UNEXPECTEDTAG . htmlspecialchars($name, ENT_QUOTES) . '<br />';
357                                 break;
358                 }
359
360                 // character data never contains other tags
361                 $this->clearCharacterData();
362
363         }
364
365         /**
366           * Called by the XML parser for each closing tag encountered
367           */
368         function endElement($parser, $name) {
369                 if ($this->debug) {
370                         echo 'END: ' . htmlspecialchars($name, ENT_QUOTES) . '<br />';
371                 }
372
373                 switch ($name) {
374                         case 'nucleusskin':
375                                 $this->inData = 0;
376                                 $this->allRead = 1;
377                                 break;
378                         case 'meta':
379                                 $this->inMeta = 0;
380                                 $this->metaDataRead = 1;
381                                 break;
382                         case 'info':
383                                 $this->info = $this->getCharacterData();
384                         case 'skin':
385                                 if (!$this->inMeta) {
386                                         $this->inSkin = 0;
387                                 }
388                                 break;
389                         case 'template':
390                                 if (!$this->inMeta) {
391                                         $this->inTemplate = 0;
392                                 }
393                                 break;
394                         case 'description':
395                                 if ($this->inSkin) {
396                                         $this->skins[$this->currentName]['description'] = $this->getCharacterData();
397                                 } else {
398                                         $this->templates[$this->currentName]['description'] = $this->getCharacterData();
399                                 }
400                                 break;
401                         case 'part':
402                                 if ($this->inSkin) {
403                                         $this->skins[$this->currentName]['parts'][$this->currentPartName] = $this->getCharacterData();
404                                 } else {
405                                         $this->templates[$this->currentName]['parts'][$this->currentPartName] = $this->getCharacterData();
406                                 }
407                                 break;
408                         default:
409                                 echo _SKINIE_SEELEMENT_UNEXPECTEDTAG . htmlspecialchars($name, ENT_QUOTES) . '<br />';
410                                 break;
411                 }
412                 $this->clearCharacterData();
413
414         }
415
416         /**
417          * Called by XML parser for data inside elements
418          */
419         function characterData ($parser, $data) {
420                 if ($this->debug) {
421                         echo 'NEW DATA: ' . htmlspecialchars($data, ENT_QUOTES) . '<br />';
422                 }
423                 $this->cdata .= $data;
424         }
425
426         /**
427          * Returns the data collected so far
428          */
429         function getCharacterData() {
430 //              echo $this->cdata;
431                 if ( (strtoupper(_CHARSET) == 'UTF-8')
432                         or (strtoupper(_CHARSET) == 'ISO-8859-1')
433                         or (!function_exists('mb_convert_encoding')) ) {
434                         return $this->cdata;
435                 } else {
436                         return mb_convert_encoding($this->cdata, _CHARSET ,'UTF-8');
437                 }
438         }
439
440         /**
441          * Clears the data buffer
442          */
443         function clearCharacterData() {
444                 $this->cdata = '';
445         }
446
447         /**
448          * Static method that looks for importable XML files in subdirs of the given dir
449          */
450         function searchForCandidates($dir) {
451                 $candidates = array();
452
453                 $dirhandle = opendir($dir);
454                 while ($filename = readdir($dirhandle)) {
455                         if (@is_dir($dir . $filename) && ($filename != '.') && ($filename != '..')) {
456                                 $xml_file = $dir . $filename . '/skinbackup.xml';
457                                 if (file_exists($xml_file) && is_readable($xml_file)) {
458                                         $candidates[$filename] = $filename; //$xml_file;
459                                 }
460
461                                 // backwards compatibility
462                                 $xml_file = $dir . $filename . '/skindata.xml';
463                                 if (file_exists($xml_file) && is_readable($xml_file)) {
464                                         $candidates[$filename] = $filename; //$xml_file;
465                                 }
466                         }
467                 }
468                 closedir($dirhandle);
469
470                 return $candidates;
471
472         }
473
474
475 }
476
477
478 class SKINEXPORT {
479
480         var $templates;
481         var $skins;
482         var $info;
483
484         /**
485          * Constructor initializes data structures
486          */
487         function SKINEXPORT() {
488                 // list of templateIDs to export
489                 $this->templates = array();
490
491                 // list of skinIDs to export
492                 $this->skins = array();
493
494                 // extra info to be in XML file
495                 $this->info = '';
496         }
497
498         /**
499          * Adds a template to be exported
500          *
501          * @param id
502          *              template ID
503          * @result false when no such ID exists
504          */
505         function addTemplate($id) {
506                 if (!TEMPLATE::existsID($id)) {
507                         return 0;
508                 }
509
510
511                 $this->templates[$id] = TEMPLATE::getNameFromId($id);
512
513                 return 1;
514         }
515
516         /**
517          * Adds a skin to be exported
518          *
519          * @param id
520          *              skin ID
521          * @result false when no such ID exists
522          */
523         function addSkin($id) {
524                 if (!SKIN::existsID($id)) {
525                         return 0;
526                 }
527
528                 $this->skins[$id] = SKIN::getNameFromId($id);
529
530                 return 1;
531         }
532
533         /**
534          * Sets the extra info to be included in the exported file
535          */
536         function setInfo($info) {
537                 $this->info = $info;
538         }
539
540
541         /**
542          * Outputs the XML contents of the export file
543          *
544          * @param $setHeaders
545          *              set to 0 if you don't want to send out headers
546          *              (optional, default 1)
547          */
548         function export($setHeaders = 1) {
549                 if ($setHeaders) {
550                         // make sure the mimetype is correct, and that the data does not show up
551                         // in the browser, but gets saved into and XML file (popup download window)
552                         header('Content-Type: text/xml');
553                         header('Content-Disposition: attachment; filename="skinbackup.xml"');
554                         header('Expires: 0');
555                         header('Pragma: no-cache');
556                 }
557
558                 echo "<nucleusskin>\n";
559
560                 // meta
561                 echo "\t<meta>\n";
562                         // skins
563                         foreach ($this->skins as $skinId => $skinName) {
564                                 $skinName = htmlspecialchars($skinName, ENT_QUOTES);
565                                 if (strtoupper(_CHARSET) != 'UTF-8') {
566                                         $skinName = mb_convert_encoding($skinName, 'UTF-8', _CHARSET);
567                                 }
568                                 echo "\t\t" . '<skin name="' . $skinName . '" />' . "\n";
569                         }
570                         // templates
571                         foreach ($this->templates as $templateId => $templateName) {
572                                 $templateName = htmlspecialchars($templateName, ENT_QUOTES);
573                                 if (strtoupper(_CHARSET) != 'UTF-8') {
574                                         $templateName = mb_convert_encoding($templateName, 'UTF-8', _CHARSET);
575                                 }
576                                 echo "\t\t" . '<template name="' . $templateName . '" />' . "\n";
577                         }
578                         // extra info
579                         if ($this->info) {
580                                 if (strtoupper(_CHARSET) != 'UTF-8') {
581                                         $skin_info = mb_convert_encoding($this->info, 'UTF-8', _CHARSET);
582                                 } else {
583                                         $skin_info = $this->info;
584                                 }
585                                 echo "\t\t<info><![CDATA[" . $skin_info . "]]></info>\n";
586                         }
587                 echo "\t</meta>\n\n\n";
588
589                 // contents skins
590                 foreach ($this->skins as $skinId => $skinName) {
591                         $skinId   = intval($skinId);
592                         $skinObj  = new SKIN($skinId);
593                         $skinName = htmlspecialchars($skinName, ENT_QUOTES);
594                         $contentT = htmlspecialchars($skinObj->getContentType(), ENT_QUOTES);
595                         $incMode  = htmlspecialchars($skinObj->getIncludeMode(), ENT_QUOTES);
596                         $incPrefx = htmlspecialchars($skinObj->getIncludePrefix(), ENT_QUOTES);
597                         $skinDesc = htmlspecialchars($skinObj->getDescription(), ENT_QUOTES);
598                         if (strtoupper(_CHARSET) != 'UTF-8') {
599                                 $skinName = mb_convert_encoding($skinName, 'UTF-8', _CHARSET);
600                                 $contentT = mb_convert_encoding($contentT, 'UTF-8', _CHARSET);
601                                 $incMode  = mb_convert_encoding($incMode,  'UTF-8', _CHARSET);
602                                 $incPrefx = mb_convert_encoding($incPrefx, 'UTF-8', _CHARSET);
603                                 $skinDesc = mb_convert_encoding($skinDesc, 'UTF-8', _CHARSET);
604                         }
605
606                         echo "\t" . '<skin name="' . $skinName . '" type="' . $contentT . '" includeMode="' . $incMode . '" includePrefix="' . $incPrefx . '">' . "\n";
607
608                         echo "\t\t" . '<description>' . $skinDesc . '</description>' . "\n";
609
610                         $que = 'SELECT'
611                                  . '    stype,'
612                                  . '    scontent '
613                                  . 'FROM '
614                                  .      sql_table('skin')
615                                  . ' WHERE'
616                                  . '    sdesc = ' . $skinId;
617                         $res = sql_query($que);
618                         while ($partObj = sql_fetch_object($res)) {
619                                 $type  = htmlspecialchars($partObj->stype, ENT_QUOTES);
620                                 $cdata = $this->escapeCDATA($partObj->scontent);
621                                 if (strtoupper(_CHARSET) != 'UTF-8') {
622                                         $type  = mb_convert_encoding($type,  'UTF-8', _CHARSET);
623                                         $cdata = mb_convert_encoding($cdata, 'UTF-8', _CHARSET);
624                                 }
625                                 echo "\t\t" . '<part name="' . $type . '">';
626                                 echo '<![CDATA[' . $cdata . ']]>';
627                                 echo "</part>\n\n";
628                         }
629
630                         echo "\t</skin>\n\n\n";
631                 }
632
633                 // contents templates
634                 foreach ($this->templates as $templateId => $templateName) {
635                         $templateId   = intval($templateId);
636                         $templateName = htmlspecialchars($templateName, ENT_QUOTES);
637                         $templateDesc = htmlspecialchars(TEMPLATE::getDesc($templateId), ENT_QUOTES);
638                         if (strtoupper(_CHARSET) != 'UTF-8') {
639                                 $templateName = mb_convert_encoding($templateName, 'UTF-8', _CHARSET);
640                                 $templateDesc = mb_convert_encoding($templateDesc, 'UTF-8', _CHARSET);
641                         }
642
643                         echo "\t" . '<template name="' . $templateName . '">' . "\n";
644
645                         echo "\t\t" . '<description>' . $templateDesc . "</description>\n";
646
647                         $que =  'SELECT'
648                                  .     ' tpartname,'
649                                  .     ' tcontent'
650                                  . ' FROM '
651                                  .     sql_table('template')
652                                  . ' WHERE'
653                                  .     ' tdesc = ' . $templateId;
654                         $res = sql_query($que);
655                         while ($partObj = sql_fetch_object($res)) {
656                                 $type  = htmlspecialchars($partObj->tpartname, ENT_QUOTES);
657                                 $cdata = $this->escapeCDATA($partObj->tcontent);
658                                 if (strtoupper(_CHARSET) != 'UTF-8') {
659                                         $type  = mb_convert_encoding($type,  'UTF-8', _CHARSET);
660                                         $cdata = mb_convert_encoding($cdata, 'UTF-8', _CHARSET);
661                                 }
662                                 echo "\t\t" . '<part name="' . $type . '">';
663                                 echo '<![CDATA[' .  $cdata . ']]>';
664                                 echo '</part>' . "\n\n";
665                         }
666
667                         echo "\t</template>\n\n\n";
668                 }
669
670                 echo '</nucleusskin>';
671         }
672
673         /**
674          * Escapes CDATA content so it can be included in another CDATA section
675          */
676         function escapeCDATA($cdata)
677         {
678                 return preg_replace('/]]>/', ']]]]><![CDATA[>', $cdata);
679
680         }
681 }
682
683 ?>