Peter M. Groen / knowledgetree

Commit e5c6be809efcf65d1d16e5fe856db2e371d06d3a

Authored by kevin_fourie 2008-01-09 14:23:10 +0000

Continuation of merge from DEV trunk.

git-svn-id: https://kt-dms.svn.sourceforge.net/svnroot/kt-dms/STABLE/trunk@7884 c91229c3-7414-0410-bfa2-8a42b809f60b

Inline Side-by-side

Showing 6 changed files with 987 additions and 43 deletions

error_01.gif deleted

View file @3c13397

2.09 KB

errors.css deleted

View file @3c13397

1	-div#error-container {
2	- width: 500px;
3	- color: #555;
4	- font-size: 11px;
5	- font-family: Verdana, Arial, sans-serif;
6	-}
7	-div#error-container div {
8	- height: 140px;
9	-}
10	-div#error-container h1 {
11	- font-weight: lighter;
12	- font-size: 22px;
13	- margin-left: 100px;
14	-}
15	-div#error-container p {
16	- margin-left: 100px;
17	-}
18	-
19	- div#acc-error {
20	- background: transparent url(error_01.gif) no-repeat top left;
21	- }
22	- div#acc-suspend {
23	- background: transparent url(error_02.gif) no-repeat top left;
24	- }
25	- div#acc-maint {
26	- background: transparent url(error_03.gif) no-repeat top left;
27	- }
28	-
29	-
30	-
31	-
32	-
33	-
34	-
35	-
36	-
37	-
38	-
39	-
40	-
41	-
42	-
43	-
44	\ No newline at end of file	0	\ No newline at end of file

thirdparty/pear/File/Archive/Predicate.php 0 → 100644

View file @e5c6be8

		1	+<?php
		2	+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
		3	+
		4	+/**
		5	+ * A predicate is an object that can evaluate to true or false depending on the
		6	+ * file currently read by a File_Archive_Reader
		7	+ *
		8	+ * @see File_Archive_Reader_Filter
		9	+ *
		10	+ * PHP versions 4 and 5
		11	+ *
		12	+ * This library is free software; you can redistribute it and/or
		13	+ * modify it under the terms of the GNU Lesser General Public
		14	+ * License as published by the Free Software Foundation; either
		15	+ * version 2.1 of the License, or (at your option) any later version.
		16	+ *
		17	+ * This library is distributed in the hope that it will be useful,
		18	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		19	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		20	+ * Lesser General Public License for more details.
		21	+ *
		22	+ * You should have received a copy of the GNU Lesser General Public
		23	+ * License along with this library; if not, write to the Free Software
		24	+ * Foundation, Inc., 59 Temple Place, Suite 330,Boston,MA 02111-1307 USA
		25	+ *
		26	+ * @category File Formats
		27	+ * @package File_Archive
		28	+ * @author Vincent Lascaux <vincentlascaux@php.net>
		29	+ * @copyright 1997-2005 The PHP Group
		30	+ * @license http://www.gnu.org/copyleft/lesser.html LGPL
		31	+ * @version CVS: $Id: Predicate.php,v 1.7 2005/05/26 21:30:18 vincentlascaux Exp $
		32	+ * @link http://pear.php.net/package/File_Archive
		33	+ */
		34	+
		35	+require_once "File/Archive/Reader.php";
		36	+
		37	+/**
		38	+ * A predicate is an object that can evaluate to true or false depending on the
		39	+ * file currently read by a File_Archive_Reader
		40	+ *
		41	+ * @see File_Archive_Reader_Filter
		42	+ */
		43	+class File_Archive_Predicate
		44	+{
		45	+ /**
		46	+ * Indicates whether the current file from the reader should be kept
		47	+ *
		48	+ * @param File_Archive_Reader $source Reader which will be filtered
		49	+ * @return bool False iif the current file must be filtered out
		50	+ */
		51	+ function isTrue(&$source)
		52	+ {
		53	+ return PEAR::raiseError("Predicat abstract function call");
		54	+ }
		55	+}
		56	+
		57	+?>
0	\ No newline at end of file	58	\ No newline at end of file

thirdparty/pear/File/Archive/Reader.php 0 → 100644

View file @e5c6be8

		1	+<?php
		2	+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
		3	+
		4	+/**
		5	+ * Abstract base class for all the readers
		6	+ *
		7	+ * A reader is a compilation of serveral files that can be read
		8	+ *
		9	+ * PHP versions 4 and 5
		10	+ *
		11	+ * This library is free software; you can redistribute it and/or
		12	+ * modify it under the terms of the GNU Lesser General Public
		13	+ * License as published by the Free Software Foundation; either
		14	+ * version 2.1 of the License, or (at your option) any later version.
		15	+ *
		16	+ * This library is distributed in the hope that it will be useful,
		17	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		18	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		19	+ * Lesser General Public License for more details.
		20	+ *
		21	+ * You should have received a copy of the GNU Lesser General Public
		22	+ * License along with this library; if not, write to the Free Software
		23	+ * Foundation, Inc., 59 Temple Place, Suite 330,Boston,MA 02111-1307 USA
		24	+ *
		25	+ * @category File Formats
		26	+ * @package File_Archive
		27	+ * @author Vincent Lascaux <vincentlascaux@php.net>
		28	+ * @copyright 1997-2005 The PHP Group
		29	+ * @license http://www.gnu.org/copyleft/lesser.html LGPL
		30	+ * @version CVS: $Id: Reader.php,v 1.33 2005/07/07 12:24:57 vincentlascaux Exp $
		31	+ * @link http://pear.php.net/package/File_Archive
		32	+ */
		33	+
		34	+require_once "PEAR.php";
		35	+
		36	+/**
		37	+ * Abstract base class for all the readers
		38	+ *
		39	+ * A reader is a compilation of serveral files that can be read
		40	+ */
		41	+class File_Archive_Reader
		42	+{
		43	+ /**
		44	+ * Move to the next file in the reader
		45	+ *
		46	+ * @return bool false iif no more files are available
		47	+ */
		48	+ function next()
		49	+ {
		50	+ return false;
		51	+ }
		52	+
		53	+ /**
		54	+ * Move to the next file whose name is in directory $filename
		55	+ * or is exactly $filename
		56	+ *
		57	+ * @param string $filename Name of the file to find in the archive
		58	+ * @param bool $close If true, close the reader and search from the first file
		59	+ * @return bool whether the file was found in the archive or not
		60	+ */
		61	+ function select($filename, $close = true)
		62	+ {
		63	+ $std = $this->getStandardURL($filename);
		64	+
		65	+ if ($close) {
		66	+ $error = $this->close();
		67	+ if (PEAR::isError($error)) {
		68	+ return $error;
		69	+ }
		70	+ }
		71	+ while (($error = $this->next()) === true) {
		72	+ $sourceName = $this->getFilename();
		73	+ if (
		74	+ empty($std) \|\|
		75	+
		76	+ //$std is a file
		77	+ $std == $sourceName \|\|
		78	+
		79	+ //$std is a directory
		80	+ strncmp($std.'/', $sourceName, strlen($std)+1) == 0
		81	+ ) {
		82	+ return true;
		83	+ }
		84	+ }
		85	+ return $error;
		86	+ }
		87	+
		88	+ /**
		89	+ * Returns the standard path
		90	+ * Changes \ to /
		91	+ * Removes the .. and . from the URL
		92	+ * @param string $path a valid URL that may contain . or .. and \
		93	+ * @static
		94	+ */
		95	+ function getStandardURL($path)
		96	+ {
		97	+ if ($path == '.') {
		98	+ return '';
		99	+ }
		100	+ $std = str_replace("\\", "/", $path);
		101	+ while ($std != ($std = preg_replace("/[^\/:?]+\/\.\.\//", "", $std))) ;
		102	+ $std = str_replace("/./", "", $std);
		103	+ if (strncmp($std, "./", 2) == 0) {
		104	+ return substr($std, 2);
		105	+ } else {
		106	+ return $std;
		107	+ }
		108	+ }
		109	+
		110	+ /**
		111	+ * Returns the name of the file currently read by the reader
		112	+ *
		113	+ * Warning: undefined behaviour if no call to next have been
		114	+ * done or if last call to next has returned false
		115	+ *
		116	+ * @return string Name of the current file
		117	+ */
		118	+ function getFilename()
		119	+ {
		120	+ return PEAR::raiseError("Reader abstract function call (getFilename)");
		121	+ }
		122	+
		123	+ /**
		124	+ * Returns the list of filenames from the current pos to the end of the source
		125	+ * The source will be closed after having called this function
		126	+ * This function goes through the whole archive (which may be slow).
		127	+ * If you intend to work on the reader, doing it in one pass would be faster
		128	+ *
		129	+ * @return array filenames from the current pos to the end of the source
		130	+ */
		131	+ function getFileList()
		132	+ {
		133	+ $result = array();
		134	+ while ( ($error = $this->next()) === true) {
		135	+ $result[] = $this->getFilename();
		136	+ }
		137	+ $this->close();
		138	+ if (PEAR::isError($error)) {
		139	+ return $error;
		140	+ } else {
		141	+ return $result;
		142	+ }
		143	+ }
		144	+
		145	+ /**
		146	+ * Returns an array of statistics about the file
		147	+ * (see the PHP stat function for more information)
		148	+ *
		149	+ * The returned array may be empty, even if readers should try
		150	+ * their best to return as many data as possible
		151	+ */
		152	+ function getStat() { return array(); }
		153	+
		154	+ /**
		155	+ * Returns the MIME associated with the current file
		156	+ * The default function does that by looking at the extension of the file
		157	+ */
		158	+ function getMime()
		159	+ {
		160	+ require_once "File/Archive/Reader/MimeList.php";
		161	+ return File_Archive_Reader_GetMime($this->getFilename());
		162	+ }
		163	+
		164	+ /**
		165	+ * If the current file of the archive is a physical file,
		166	+ *
		167	+ * @return the name of the physical file containing the data
		168	+ * or null if no such file exists
		169	+ *
		170	+ * The data filename may not be the same as the filename.
		171	+ */
		172	+ function getDataFilename() { return null; }
		173	+
		174	+ /**
		175	+ * Reads some data from the current file
		176	+ * If the end of the file is reached, returns null
		177	+ * If $length is not specified, reads up to the end of the file
		178	+ * If $length is specified reads up to $length
		179	+ */
		180	+ function getData($length = -1)
		181	+ {
		182	+ return PEAR::raiseError("Reader abstract function call (getData)");
		183	+ }
		184	+
		185	+ /**
		186	+ * Skip some data and returns how many bytes have been skipped
		187	+ * This is strictly equivalent to
		188	+ * return strlen(getData($length))
		189	+ * But could be far more efficient
		190	+ */
		191	+ function skip($length = -1)
		192	+ {
		193	+ $data = $this->getData($length);
		194	+ if (PEAR::isError($data)) {
		195	+ return $data;
		196	+ } else {
		197	+ return strlen($data);
		198	+ }
		199	+ }
		200	+
		201	+ /**
		202	+ * Move the current position back of a given amount of bytes.
		203	+ * Not all readers may implement this function (a PEAR error will
		204	+ * be returned if the reader can't rewind)
		205	+ *
		206	+ * @param int $length number of bytes to seek before the current pos
		207	+ * or -1 to move back to the begining of the current file
		208	+ * @return the number of bytes really rewinded (which may be less than
		209	+ * $length if the current pos is less than $length
		210	+ */
		211	+ function rewind($length = -1)
		212	+ {
		213	+ return PEAR::raiseError('Rewind function is not implemented on this reader');
		214	+ }
		215	+
		216	+ /**
		217	+ * Returns the current offset in the current file
		218	+ */
		219	+ function tell()
		220	+ {
		221	+ $offset = $this->rewind();
		222	+ $this->skip($offset);
		223	+ return $offset;
		224	+ }
		225	+
		226	+ /**
		227	+ * Put back the reader in the state it was before the first call
		228	+ * to next()
		229	+ */
		230	+ function close()
		231	+ {
		232	+ }
		233	+
		234	+ /**
		235	+ * Sends the current file to the Writer $writer
		236	+ * The data will be sent by chunks of at most $bufferSize bytes
		237	+ * If $bufferSize <= 0 (default), the blockSize option is used
		238	+ */
		239	+ function sendData(&$writer, $bufferSize = 0)
		240	+ {
		241	+ if (PEAR::isError($writer)) {
		242	+ return $writer;
		243	+ }
		244	+ if ($bufferSize <= 0) {
		245	+ $bufferSize = File_Archive::getOption('blockSize');
		246	+ }
		247	+
		248	+ $filename = $this->getDataFilename();
		249	+ if ($filename !== null) {
		250	+ $error = $writer->writeFile($filename);
		251	+ if (PEAR::isError($error)) {
		252	+ return $error;
		253	+ }
		254	+ } else {
		255	+ while (($data = $this->getData($bufferSize)) !== null) {
		256	+ if (PEAR::isError($data)) {
		257	+ return $data;
		258	+ }
		259	+ $error = $writer->writeData($data);
		260	+ if (PEAR::isError($error)) {
		261	+ return $error;
		262	+ }
		263	+ }
		264	+ }
		265	+ }
		266	+
		267	+ /**
		268	+ * Sends the whole reader to $writer and close the reader
		269	+ *
		270	+ * @param File_Archive_Writer $writer Where to write the files of the reader
		271	+ * @param bool $autoClose If true, close $writer at the end of the function.
		272	+ * Default value is true
		273	+ * @param int $bufferSize Size of the chunks that will be sent to the writer
		274	+ * If $bufferSize <= 0 (default value), the blockSize option is used
		275	+ */
		276	+ function extract(&$writer, $autoClose = true, $bufferSize = 0)
		277	+ {
		278	+ if (PEAR::isError($writer)) {
		279	+ $this->close();
		280	+ return $writer;
		281	+ }
		282	+
		283	+ while (($error = $this->next()) === true) {
		284	+ if ($writer->newFileNeedsMIME()) {
		285	+ $mime = $this->getMime();
		286	+ } else {
		287	+ $mime = null;
		288	+ }
		289	+ $error = $writer->newFile(
		290	+ $this->getFilename(),
		291	+ $this->getStat(),
		292	+ $mime
		293	+ );
		294	+ if (PEAR::isError($error)) {
		295	+ break;
		296	+ }
		297	+ $error = $this->sendData($writer, $bufferSize);
		298	+ if (PEAR::isError($error)) {
		299	+ break;
		300	+ }
		301	+ }
		302	+ $this->close();
		303	+ if ($autoClose) {
		304	+ $writer->close();
		305	+ }
		306	+ if (PEAR::isError($error)) {
		307	+ return $error;
		308	+ }
		309	+ }
		310	+
		311	+ /**
		312	+ * Extract only one file (given by the URL)
		313	+ *
		314	+ * @param string $filename URL of the file to extract from this
		315	+ * @param File_Archive_Writer $writer Where to write the file
		316	+ * @param bool $autoClose If true, close $writer at the end of the function
		317	+ * Default value is true
		318	+ * @param int $bufferSize Size of the chunks that will be sent to the writer
		319	+ * If $bufferSize <= 0 (default value), the blockSize option is used
		320	+ */
		321	+ function extractFile($filename, &$writer,
		322	+ $autoClose = true, $bufferSize = 0)
		323	+ {
		324	+ if (PEAR::isError($writer)) {
		325	+ return $writer;
		326	+ }
		327	+
		328	+ if (($error = $this->select($filename)) === true) {
		329	+ $result = $this->sendData($writer, $bufferSize);
		330	+ if (!PEAR::isError($result)) {
		331	+ $result = true;
		332	+ }
		333	+ } else if ($error === false) {
		334	+ $result = PEAR::raiseError("File $filename not found");
		335	+ } else {
		336	+ $result = $error;
		337	+ }
		338	+ if ($autoClose) {
		339	+ $error = $writer->close();
		340	+ if (PEAR::isError($error)) {
		341	+ return $error;
		342	+ }
		343	+ }
		344	+ return $result;
		345	+ }
		346	+
		347	+ /**
		348	+ * Return a writer that allows appending files to the archive
		349	+ * After having called makeAppendWriter, $this is closed and should not be
		350	+ * used until the returned writer is closed.
		351	+ *
		352	+ * @return a writer that will allow to append files to an existing archive
		353	+ * @see makeWriter
		354	+ */
		355	+ function makeAppendWriter()
		356	+ {
		357	+ require_once "File/Archive/Predicate/False.php";
		358	+ return $this->makeWriterRemoveFiles(new File_Archive_Predicate_False());
		359	+ }
		360	+
		361	+ /**
		362	+ * Return a writer that has the same properties as the one returned by
		363	+ * makeAppendWriter, but after having removed all the files that follow a
		364	+ * given predicate.
		365	+ * After a call to makeWriterRemoveFiles, $this is closed and should not
		366	+ * be used until the returned writer is closed
		367	+ *
		368	+ * @param File_Archive_Predicate $pred the predicate verified by removed files
		369	+ * @return File_Archive_Writer that allows to append files to the archive
		370	+ */
		371	+ function makeWriterRemoveFiles($pred)
		372	+ {
		373	+ return PEAR::raiseError("Reader abstract function call (makeWriterRemoveFiles)");
		374	+ }
		375	+
		376	+ /**
		377	+ * Returns a writer that removes the current file
		378	+ * This is a syntaxic sugar for makeWriterRemoveFiles(new File_Archive_Predicate_Current());
		379	+ */
		380	+ function makeWriterRemove()
		381	+ {
		382	+ require_once "File/Archive/Predicate/Current.php";
		383	+ return $this->makeWriterRemoveFiles(new File_Archive_Predicate_Current());
		384	+ }
		385	+
		386	+ /**
		387	+ * Removes the current file from the reader
		388	+ */
		389	+ function remove()
		390	+ {
		391	+ $writer = $this->makeWriterRemove();
		392	+ if (PEAR::isError($writer)) {
		393	+ return $writer;
		394	+ }
		395	+ $writer->close();
		396	+ }
		397	+
		398	+ /**
		399	+ * Return a writer that has the same properties as the one returned by makeWriter, but after
		400	+ * having removed a block of data from the current file. The writer will append data to the current file
		401	+ * no data (other than the block) will be removed
		402	+ *
		403	+ * @param array Lengths of the blocks. The first one will be discarded, the second one kept, the third
		404	+ * one discarded... If the sum of the blocks is less than the size of the file, the comportment is the
		405	+ * same as if a last block was set in the array to reach the size of the file
		406	+ * if $length is -1, the file is truncated from the specified pos
		407	+ * It is possible to specify blocks of size 0
		408	+ * @param int $seek relative pos of the block
		409	+ */
		410	+ function makeWriterRemoveBlocks($blocks, $seek = 0)
		411	+ {
		412	+ return PEAR::raiseError("Reader abstract function call (makeWriterRemoveBlocks)");
		413	+ }
		414	+}
		415	+
		416	+?>
0	\ No newline at end of file	417	\ No newline at end of file

thirdparty/pear/File/Archive/Writer.php 0 → 100644

View file @e5c6be8

		1	+<?php
		2	+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
		3	+
		4	+/**
		5	+ * Base class for any writer
		6	+ *
		7	+ * PHP versions 4 and 5
		8	+ *
		9	+ * This library is free software; you can redistribute it and/or
		10	+ * modify it under the terms of the GNU Lesser General Public
		11	+ * License as published by the Free Software Foundation; either
		12	+ * version 2.1 of the License, or (at your option) any later version.
		13	+ *
		14	+ * This library is distributed in the hope that it will be useful,
		15	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		16	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		17	+ * Lesser General Public License for more details.
		18	+ *
		19	+ * You should have received a copy of the GNU Lesser General Public
		20	+ * License along with this library; if not, write to the Free Software
		21	+ * Foundation, Inc., 59 Temple Place, Suite 330,Boston,MA 02111-1307 USA
		22	+ *
		23	+ * @category File Formats
		24	+ * @package File_Archive
		25	+ * @author Vincent Lascaux <vincentlascaux@php.net>
		26	+ * @copyright 1997-2005 The PHP Group
		27	+ * @license http://www.gnu.org/copyleft/lesser.html LGPL
		28	+ * @version CVS: $Id: Writer.php,v 1.12 2005/05/31 21:22:02 vincentlascaux Exp $
		29	+ * @link http://pear.php.net/package/File_Archive
		30	+ */
		31	+
		32	+require_once "PEAR.php";
		33	+
		34	+/**
		35	+ * Base class for any writer
		36	+ */
		37	+class File_Archive_Writer
		38	+{
		39	+ /**
		40	+ * Create a new file in the writer
		41	+ *
		42	+ * @param string $filename Name of the file, eventually including a path
		43	+ * @param array $stat Its Statistics. None of the indexes are required
		44	+ * @param string $mime MIME type of the file
		45	+ */
		46	+ function newFile($filename, $stat = array(), $mime = "application/octet-stream")
		47	+ {
		48	+ }
		49	+
		50	+ /**
		51	+ * Create a new file in the writer with the content of the physical file $filename
		52	+ * and then unlink $filename.
		53	+ * newFromTempFile($tmpfile, $filename, $stat, $mime) is equivalent to
		54	+ * newFile($filename, $stat, $mime); writeFile($tmpfile); unlink($tmpfile);
		55	+ * but can be more efficient.
		56	+ * A typical use is for File_Archive_Writer_Files: it renames the temporary
		57	+ * file instead of copy/delete
		58	+ *
		59	+ * @param string $tmpfile Name of the physical file that contains data and will be unlinked
		60	+ * @param string $filename Name of the file, eventually including a path
		61	+ * @param array $stat Its Statistics. None of the indexes are required
		62	+ * @param string $mime MIME type of the file
		63	+ */
		64	+ function newFromTempFile($tmpfile, $filename, $stat = array(), $mime = "application/octet-stream")
		65	+ {
		66	+ $this->newFile($filename, $stat, $mime);
		67	+ $this->writeFile($tmpfile);
		68	+ unlink($tmpfile);
		69	+ }
		70	+
		71	+ /**
		72	+ * Returns whether the writer newFile function needs the $mime parameter
		73	+ * Default is false
		74	+ */
		75	+ function newFileNeedsMIME()
		76	+ {
		77	+ return false;
		78	+ }
		79	+
		80	+ /**
		81	+ * Append the specified data to the writer
		82	+ *
		83	+ * @param String $data the data to append to the writer
		84	+ */
		85	+ function writeData($data)
		86	+ {
		87	+ }
		88	+
		89	+ /**
		90	+ * Append the content of the physical file $filename to the writer
		91	+ * writeFile($filename) must be equivalent to
		92	+ * writeData(file_get_contents($filename)) but can be more efficient
		93	+ *
		94	+ * @param string $filename Name of the file which content must be appended
		95	+ * to the writer
		96	+ */
		97	+ function writeFile($filename)
		98	+ {
		99	+ $handle = fopen($filename, "r");
		100	+ if (!is_resource($handle)) {
		101	+ return PEAR::raiseError("Unable to write to $filename");
		102	+ }
		103	+ while (!feof($handle)) {
		104	+ $error = $this->writeData(fread($handle, 102400));
		105	+ if (PEAR::isError($error)) {
		106	+ return $error;
		107	+ }
		108	+ }
		109	+ fclose($handle);
		110	+ }
		111	+
		112	+ /**
		113	+ * Close the writer, eventually flush the data, write the footer...
		114	+ * This function must be called before the end of the script
		115	+ */
		116	+ function close() { }
		117	+}
		118	+
		119	+?>
0	\ No newline at end of file	120	\ No newline at end of file

thirdparty/pear/MIME/Type.php 0 → 100644

View file @e5c6be8

		1	+<?php
		2	+/* vim: set expandtab tabstop=4 shiftwidth=4: */
		3	+// +----------------------------------------------------------------------+
		4	+// \| PHP version 4 \|
		5	+// +----------------------------------------------------------------------+
		6	+// \| Copyright (c) 1997-2002 The PHP Group \|
		7	+// +----------------------------------------------------------------------+
		8	+// \| This source file is subject to version 3.0 of the PHP license, \|
		9	+// \| that is bundled with this package in the file LICENSE, and is \|
		10	+// \| available at through the world-wide-web at \|
		11	+// \| http://www.php.net/license/3_0.txt. \|
		12	+// \| If you did not receive a copy of the PHP license and are unable to \|
		13	+// \| obtain it through the world-wide-web, please send a note to \|
		14	+// \| license@php.net so we can mail you a copy immediately. \|
		15	+// +----------------------------------------------------------------------+
		16	+// \| Authors: Ian Eure <ieure@php.net> \|
		17	+// +----------------------------------------------------------------------+
		18	+//
		19	+// $Id: Type.php,v 1.2 2004/08/07 22:19:04 ieure Exp $
		20	+
		21	+require_once 'PEAR.php';
		22	+
		23	+$_fileCmd = &PEAR::getStaticProperty('MIME_Type', 'fileCmd');
		24	+$_fileCmd = 'file';
		25	+
		26	+/**
		27	+ * Class for working with MIME types
		28	+ *
		29	+ * @version @version@
		30	+ * @package @package@
		31	+ * @author Ian Eure <ieure@php.net>
		32	+ */
		33	+class MIME_Type {
		34	+ /**
		35	+ * The MIME media type
		36	+ *
		37	+ * @var string
		38	+ */
		39	+ var $media = '';
		40	+
		41	+ /**
		42	+ * The MIME media sub-type
		43	+ *
		44	+ * @var string
		45	+ */
		46	+ var $subType = '';
		47	+
		48	+ /**
		49	+ * Optional MIME parameters
		50	+ *
		51	+ * @var array
		52	+ */
		53	+ var $parameters = array();
		54	+
		55	+ /**
		56	+ * List of valid media types
		57	+ *
		58	+ * @var array
		59	+ */
		60	+ var $validMediaTypes = array(
		61	+ 'text',
		62	+ 'image',
		63	+ 'audio',
		64	+ 'video',
		65	+ 'application',
		66	+ 'multipart',
		67	+ 'message'
		68	+ );
		69	+
		70	+
		71	+ /**
		72	+ * Constructor.
		73	+ *
		74	+ * If $type is set, if will be parsed and the appropriate class vars set. If not,
		75	+ * you get an empty class. This is useful, but not quite as useful as parsing a
		76	+ * type.
		77	+ *
		78	+ * @param string $type MIME type
		79	+ * @return void
		80	+ */
		81	+ function MIME_Type($type = false)
		82	+ {
		83	+ if ($type) {
		84	+ $this->parse($type);
		85	+ }
		86	+ }
		87	+
		88	+
		89	+ /**
		90	+ * Parse a mime-type
		91	+ *
		92	+ * @param $type string MIME type to parse
		93	+ * @return void
		94	+ */
		95	+ function parse($type)
		96	+ {
		97	+ $this->media = $this->getMedia($type);
		98	+ $this->subType = $this->getSubType($type);
		99	+ if (MIME_Type::hasParameters($type)) {
		100	+ require_once 'MIME/Type/Parameter.php';
		101	+ foreach (MIME_Type::getParameters($type) as $param) {
		102	+ $param = &new MIME_Type_Parameter($param);
		103	+ $this->parameters[$param->name] = $param;
		104	+ }
		105	+ }
		106	+ }
		107	+
		108	+
		109	+ /**
		110	+ * Does this type have any parameters?
		111	+ *
		112	+ * @param $type string MIME type to check
		113	+ * @return boolean true if $type has parameters, false otherwise
		114	+ * @static
		115	+ */
		116	+ function hasParameters($type)
		117	+ {
		118	+ if (strstr($type, ';')) {
		119	+ return true;
		120	+ }
		121	+ return false;
		122	+ }
		123	+
		124	+
		125	+ /**
		126	+ * Get a MIME type's parameters
		127	+ *
		128	+ * @param $type string MIME type to get parameters of
		129	+ * @return array $type's parameters
		130	+ * @static
		131	+ */
		132	+ function getParameters($type)
		133	+ {
		134	+ $params = array();
		135	+ $tmp = explode(';', $type);
		136	+ for ($i = 1; $i < count($tmp); $i++) {
		137	+ $params[] = trim($tmp[$i]);
		138	+ }
		139	+ return $params;
		140	+ }
		141	+
		142	+
		143	+ /**
		144	+ * Strip paramaters from a MIME type string
		145	+ *
		146	+ * @param string $type MIME type string
		147	+ * @return string MIME type with parameters removed
		148	+ * @static
		149	+ */
		150	+ function stripParameters($type)
		151	+ {
		152	+ if (strstr($type, ';')) {
		153	+ return substr($type, 0, strpos($type, ';'));
		154	+ }
		155	+ return $type;
		156	+ }
		157	+
		158	+
		159	+ /**
		160	+ * Get a MIME type's media
		161	+ *
		162	+ * @note 'media' refers to the portion before the first slash
		163	+ * @param $type string MIME type to get media of
		164	+ * @return string $type's media
		165	+ * @static
		166	+ */
		167	+ function getMedia($type)
		168	+ {
		169	+ $tmp = explode('/', $type);
		170	+ return strtolower($tmp[0]);
		171	+ }
		172	+
		173	+
		174	+ /**
		175	+ * Get a MIME type's subtype
		176	+ *
		177	+ * @param $type string MIME type to get subtype of
		178	+ * @return string $type's subtype
		179	+ * @static
		180	+ */
		181	+ function getSubType($type)
		182	+ {
		183	+ $tmp = explode('/', $type);
		184	+ $tmp = explode(';', $tmp[1]);
		185	+ return strtolower(trim($tmp[0]));
		186	+ }
		187	+
		188	+
		189	+ /**
		190	+ * Create a textual MIME type from object values
		191	+ *
		192	+ * This function performs the opposite function of parse().
		193	+ *
		194	+ * @return string MIME type string
		195	+ */
		196	+ function get()
		197	+ {
		198	+ $type = strtolower($this->media.'/'.$this->subType);
		199	+ if (count($this->parameters)) {
		200	+ foreach ($this->parameters as $key => $null) {
		201	+ $type .= '; '.$this->parameters[$key]->get();
		202	+ }
		203	+ }
		204	+ return $type;
		205	+ }
		206	+
		207	+
		208	+ /**
		209	+ * Is this type experimental?
		210	+ *
		211	+ * @note Experimental types are denoted by a leading 'x-' in the media or
		212	+ * subtype, e.g. text/x-vcard or x-world/x-vrml.
		213	+ * @param string $type MIME type to check
		214	+ * @return boolean true if $type is experimental, false otherwise
		215	+ * @static
		216	+ */
		217	+ function isExperimental($type)
		218	+ {
		219	+ if (substr(MIME_Type::getMedia($type), 0, 2) == 'x-' \|\|
		220	+ substr(MIME_Type::getSubType($type), 0, 2) == 'x-') {
		221	+ return true;
		222	+ }
		223	+ return false;
		224	+ }
		225	+
		226	+
		227	+ /**
		228	+ * Is this a vendor MIME type?
		229	+ *
		230	+ * @note Vendor types are denoted with a leading 'vnd. in the subtype.
		231	+ * @param string $type MIME type to check
		232	+ * @return boolean true if $type is a vendor type, false otherwise
		233	+ * @static
		234	+ */
		235	+ function isVendor($type)
		236	+ {
		237	+ if (substr(MIME_Type::getSubType($type), 0, 4) == 'vnd.') {
		238	+ return true;
		239	+ }
		240	+ return false;
		241	+ }
		242	+
		243	+
		244	+ /**
		245	+ * Is this a wildcard type?
		246	+ *
		247	+ * @param string $type MIME type to check
		248	+ * @return boolean true if $type is a wildcard, false otherwise
		249	+ * @static
		250	+ */
		251	+ function isWildcard($type)
		252	+ {
		253	+ if ($type == '/' \|\| MIME_Type::getSubtype($type) == '*') {
		254	+ return true;
		255	+ }
		256	+ return false;
		257	+ }
		258	+
		259	+
		260	+ /**
		261	+ * Perform a wildcard match on a MIME type
		262	+ *
		263	+ * Example:
		264	+ * MIME_Type::wildcardMatch('image/*', 'image/png')
		265	+ *
		266	+ * @param string $card Wildcard to check against
		267	+ * @param string $type MIME type to check
		268	+ * @return boolean true if there was a match, false otherwise
		269	+ */
		270	+ function wildcardMatch($card, $type)
		271	+ {
		272	+ if (!MIME_Type::isWildcard($card)) {
		273	+ return false;
		274	+ }
		275	+
		276	+ if ($card == '/') {
		277	+ return true;
		278	+ }
		279	+
		280	+ if (MIME_Type::getMedia($card) ==
		281	+ MIME_Type::getMedia($type)) {
		282	+ return true;
		283	+ }
		284	+ return false;
		285	+ }
		286	+
		287	+
		288	+ /**
		289	+ * Add a parameter to this type
		290	+ *
		291	+ * @param string $name Attribute name
		292	+ * @param string $value Attribute value
		293	+ * @param string $comment Comment for this parameter
		294	+ * @return void
		295	+ */
		296	+ function addParameter($name, $value, $comment = false)
		297	+ {
		298	+ $tmp = &new MIME_Type_Parameter;
		299	+ $tmp->name = $name;
		300	+ $tmp->value = $value;
		301	+ $tmp->comment = $comment;
		302	+ $this->parameters[$name] = $tmp;
		303	+ }
		304	+
		305	+
		306	+ /**
		307	+ * Remove a parameter from this type
		308	+ *
		309	+ * @param string $name Parameter name
		310	+ * @return void
		311	+ */
		312	+ function removeParameter($name)
		313	+ {
		314	+ unset ($this->parameters[$name]);
		315	+ }
		316	+
		317	+
		318	+ /**
		319	+ * Autodetect a file's MIME-type
		320	+ *
		321	+ * This function may be called staticly.
		322	+ *
		323	+ * @param string $file Path to the file to get the type of
		324	+ * @param bool $params Append MIME parameters if true
		325	+ * @return string $file's MIME-type on success, PEAR_Error otherwise
		326	+ * @since 1.0.0beta1
		327	+ * @static
		328	+ */
		329	+ function autoDetect($file, $params = false)
		330	+ {
		331	+ @include_once 'System/Command.php';
		332	+ if (function_exists('mime_content_type')) {
		333	+ $type = mime_content_type($file);
		334	+ } else if (class_exists('System_Command')) {
		335	+ $type = MIME_Type::_fileAutoDetect($file);
		336	+ } else {
		337	+ return PEAR::raiseError("Sorry, can't autodetect; you need the mime_magic extension or System_Command and 'file' installed to use this function.");
		338	+ }
		339	+
		340	+ // _fileAutoDetect() may have returned an error.
		341	+ if (PEAR::isError($type)) {
		342	+ return $type;
		343	+ }
		344	+
		345	+ // Don't return an empty string
		346	+ if (!$type \|\| !strlen($type)) {
		347	+ return PEAR::raiseError("Sorry, couldn't determine file type.");
		348	+ }
		349	+
		350	+ // Strip parameters if present & requested
		351	+ if (MIME_Type::hasParameters($type) && !$params) {
		352	+ $type = MIME_Type::stripParameters($type);
		353	+ }
		354	+
		355	+ return $type;
		356	+ }
		357	+
		358	+ /**
		359	+ * Autodetect a file's MIME-type with 'file' and System_Command
		360	+ *
		361	+ * This function may be called staticly.
		362	+ *
		363	+ * @param string $file Path to the file to get the type of
		364	+ * @return string $file's MIME-type
		365	+ * @since 1.0.0beta1
		366	+ * @static
		367	+ */
		368	+ function _fileAutoDetect($file)
		369	+ {
		370	+ // Sanity checks
		371	+ if (!file_exists($file)) {
		372	+ return PEAR::raiseError("File \"$file\" doesn't exist");
		373	+ }
		374	+
		375	+ if (!is_readable($file)) {
		376	+ return PEAR::raiseError("File \"$file\" is not readable");
		377	+ }
		378	+
		379	+ $cmd = new System_Command;
		380	+
		381	+
		382	+ // Make sure we have the 'file' command.
		383	+ $fileCmd = PEAR::getStaticProperty('MIME_Type', 'fileCmd');
		384	+ if (!$cmd->which($fileCmd)) {
		385	+ unset($cmd);
		386	+ return PEAR::raiseError("Can't find file command \"{$fileCmd}\"");
		387	+ }
		388	+
		389	+ $cmd->pushCommand($fileCmd, "-bi '{$file}'");
		390	+ $res = $cmd->execute();
		391	+ unset($cmd);
		392	+
		393	+ return $res;
		394	+ }
		395	+}
0	\ No newline at end of file	396	\ No newline at end of file