Subversion Repositories eFlore/Applications.cel

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
2388 jpm 1
<?php
2
/**
3
 * PHPExcel
4
 *
5
 * Copyright (C) 2006 - 2013 PHPExcel
6
 *
7
 * This library is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * This library is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with this library; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
20
 *
21
 * @category   PHPExcel
22
 * @package    PHPExcel_Shared_OLE
23
 * @copyright  Copyright (c) 2006 - 2007 Christian Schmidt
24
 * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
25
 * @version ##VERSION##, ##DATE##
26
 */
27
 
28
/**
29
 * PHPExcel_Shared_OLE_ChainedBlockStream
30
 *
31
 * Stream wrapper for reading data stored in an OLE file. Implements methods
32
 * for PHP's stream_wrapper_register(). For creating streams using this
33
 * wrapper, use PHPExcel_Shared_OLE_PPS_File::getStream().
34
 *
35
 * @category   PHPExcel
36
 * @package    PHPExcel_Shared_OLE
37
 */
38
class PHPExcel_Shared_OLE_ChainedBlockStream
39
{
40
	/**
41
	 * The OLE container of the file that is being read.
42
	 * @var OLE
43
	 */
44
	public $ole;
45
 
46
	/**
47
	 * Parameters specified by fopen().
48
	 * @var array
49
	 */
50
	public $params;
51
 
52
	/**
53
	 * The binary data of the file.
54
	 * @var  string
55
	 */
56
	public $data;
57
 
58
	/**
59
	 * The file pointer.
60
	 * @var  int  byte offset
61
	 */
62
	public $pos;
63
 
64
	/**
65
	 * Implements support for fopen().
66
	 * For creating streams using this wrapper, use OLE_PPS_File::getStream().
67
	 *
68
	 * @param	string	$path			resource name including scheme, e.g.
69
	 *									ole-chainedblockstream://oleInstanceId=1
70
	 * @param	string	$mode			only "r" is supported
71
	 * @param	int		$options		mask of STREAM_REPORT_ERRORS and STREAM_USE_PATH
72
	 * @param	string  &$openedPath	absolute path of the opened stream (out parameter)
73
	 * @return	bool    true on success
74
	 */
75
	public function stream_open($path, $mode, $options, &$openedPath)
76
	{
77
		if ($mode != 'r') {
78
			if ($options & STREAM_REPORT_ERRORS) {
79
				trigger_error('Only reading is supported', E_USER_WARNING);
80
			}
81
			return false;
82
		}
83
 
84
		// 25 is length of "ole-chainedblockstream://"
85
		parse_str(substr($path, 25), $this->params);
86
		if (!isset($this->params['oleInstanceId'],
87
				   $this->params['blockId'],
88
				   $GLOBALS['_OLE_INSTANCES'][$this->params['oleInstanceId']])) {
89
 
90
			if ($options & STREAM_REPORT_ERRORS) {
91
				trigger_error('OLE stream not found', E_USER_WARNING);
92
			}
93
			return false;
94
		}
95
		$this->ole = $GLOBALS['_OLE_INSTANCES'][$this->params['oleInstanceId']];
96
 
97
		$blockId = $this->params['blockId'];
98
		$this->data = '';
99
		if (isset($this->params['size']) &&
100
			$this->params['size'] < $this->ole->bigBlockThreshold &&
101
			$blockId != $this->ole->root->_StartBlock) {
102
 
103
			// Block id refers to small blocks
104
			$rootPos = $this->ole->_getBlockOffset($this->ole->root->_StartBlock);
105
			while ($blockId != -2) {
106
				$pos = $rootPos + $blockId * $this->ole->bigBlockSize;
107
				$blockId = $this->ole->sbat[$blockId];
108
				fseek($this->ole->_file_handle, $pos);
109
				$this->data .= fread($this->ole->_file_handle, $this->ole->bigBlockSize);
110
			}
111
		} else {
112
			// Block id refers to big blocks
113
			while ($blockId != -2) {
114
				$pos = $this->ole->_getBlockOffset($blockId);
115
				fseek($this->ole->_file_handle, $pos);
116
				$this->data .= fread($this->ole->_file_handle, $this->ole->bigBlockSize);
117
				$blockId = $this->ole->bbat[$blockId];
118
			}
119
		}
120
		if (isset($this->params['size'])) {
121
			$this->data = substr($this->data, 0, $this->params['size']);
122
		}
123
 
124
		if ($options & STREAM_USE_PATH) {
125
			$openedPath = $path;
126
		}
127
 
128
		return true;
129
	}
130
 
131
	/**
132
	 * Implements support for fclose().
133
	 *
134
	 */
135
	public function stream_close()
136
	{
137
		$this->ole = null;
138
		unset($GLOBALS['_OLE_INSTANCES']);
139
	}
140
 
141
	/**
142
	 * Implements support for fread(), fgets() etc.
143
	 *
144
	 * @param   int		$count	maximum number of bytes to read
145
	 * @return  string
146
	 */
147
	public function stream_read($count)
148
	{
149
		if ($this->stream_eof()) {
150
			return false;
151
		}
152
		$s = substr($this->data, $this->pos, $count);
153
		$this->pos += $count;
154
		return $s;
155
	}
156
 
157
	/**
158
	 * Implements support for feof().
159
	 *
160
	 * @return  bool  TRUE if the file pointer is at EOF; otherwise FALSE
161
	 */
162
	public function stream_eof()
163
	{
164
		$eof = $this->pos >= strlen($this->data);
165
		// Workaround for bug in PHP 5.0.x: http://bugs.php.net/27508
166
		if (version_compare(PHP_VERSION, '5.0', '>=') &&
167
			version_compare(PHP_VERSION, '5.1', '<')) {
168
 
169
		   $eof = !$eof;
170
		}
171
		return $eof;
172
	}
173
 
174
	/**
175
	 * Returns the position of the file pointer, i.e. its offset into the file
176
	 * stream. Implements support for ftell().
177
	 *
178
	 * @return  int
179
	 */
180
	public function stream_tell()
181
	{
182
		return $this->pos;
183
	}
184
 
185
	/**
186
	 * Implements support for fseek().
187
	 *
188
	 * @param	int		$offset	byte offset
189
	 * @param	int		$whence	SEEK_SET, SEEK_CUR or SEEK_END
190
	 * @return	bool
191
	 */
192
	public function stream_seek($offset, $whence)
193
	{
194
		if ($whence == SEEK_SET && $offset >= 0) {
195
			$this->pos = $offset;
196
		} elseif ($whence == SEEK_CUR && -$offset <= $this->pos) {
197
			$this->pos += $offset;
198
		} elseif ($whence == SEEK_END && -$offset <= sizeof($this->data)) {
199
			$this->pos = strlen($this->data) + $offset;
200
		} else {
201
			return false;
202
		}
203
		return true;
204
	}
205
 
206
	/**
207
	 * Implements support for fstat(). Currently the only supported field is
208
	 * "size".
209
	 * @return  array
210
	 */
211
	public function stream_stat()
212
	{
213
		return array(
214
			'size' => strlen($this->data),
215
			);
216
	}
217
 
218
	// Methods used by stream_wrapper_register() that are not implemented:
219
	// bool stream_flush ( void )
220
	// int stream_write ( string data )
221
	// bool rename ( string path_from, string path_to )
222
	// bool mkdir ( string path, int mode, int options )
223
	// bool rmdir ( string path, int options )
224
	// bool dir_opendir ( string path, int options )
225
	// array url_stat ( string path, int flags )
226
	// string dir_readdir ( void )
227
	// bool dir_rewinddir ( void )
228
	// bool dir_closedir ( void )
229
}