|
0
|
1 <?php
|
|
|
2
|
|
|
3 /**
|
|
|
4 +-----------------------------------------------------------------------+
|
|
|
5 | program/include/rcmail_output_html.php |
|
|
|
6 | |
|
|
|
7 | This file is part of the Roundcube Webmail client |
|
|
|
8 | Copyright (C) 2006-2014, The Roundcube Dev Team |
|
|
|
9 | |
|
|
|
10 | Licensed under the GNU General Public License version 3 or |
|
|
|
11 | any later version with exceptions for skins & plugins. |
|
|
|
12 | See the README file for a full license statement. |
|
|
|
13 | |
|
|
|
14 | PURPOSE: |
|
|
|
15 | Class to handle HTML page output using a skin template. |
|
|
|
16 | |
|
|
|
17 +-----------------------------------------------------------------------+
|
|
|
18 | Author: Thomas Bruederli <roundcube@gmail.com> |
|
|
|
19 +-----------------------------------------------------------------------+
|
|
|
20 */
|
|
|
21
|
|
|
22 /**
|
|
|
23 * Class to create HTML page output using a skin template
|
|
|
24 *
|
|
|
25 * @package Webmail
|
|
|
26 * @subpackage View
|
|
|
27 */
|
|
|
28 class rcmail_output_html extends rcmail_output
|
|
|
29 {
|
|
|
30 public $type = 'html';
|
|
|
31
|
|
|
32 protected $message;
|
|
|
33 protected $template_name;
|
|
|
34 protected $objects = array();
|
|
|
35 protected $js_env = array();
|
|
|
36 protected $js_labels = array();
|
|
|
37 protected $js_commands = array();
|
|
|
38 protected $skin_paths = array();
|
|
|
39 protected $scripts_path = '';
|
|
|
40 protected $script_files = array();
|
|
|
41 protected $css_files = array();
|
|
|
42 protected $scripts = array();
|
|
|
43 protected $default_template = "<html>\n<head><title></title></head>\n<body></body>\n</html>";
|
|
|
44 protected $header = '';
|
|
|
45 protected $footer = '';
|
|
|
46 protected $body = '';
|
|
|
47 protected $base_path = '';
|
|
|
48 protected $assets_path;
|
|
|
49 protected $assets_dir = RCUBE_INSTALL_PATH;
|
|
|
50 protected $devel_mode = false;
|
|
|
51
|
|
|
52 // deprecated names of templates used before 0.5
|
|
|
53 protected $deprecated_templates = array(
|
|
|
54 'contact' => 'showcontact',
|
|
|
55 'contactadd' => 'addcontact',
|
|
|
56 'contactedit' => 'editcontact',
|
|
|
57 'identityedit' => 'editidentity',
|
|
|
58 'messageprint' => 'printmessage',
|
|
|
59 );
|
|
|
60
|
|
|
61 /**
|
|
|
62 * Constructor
|
|
|
63 */
|
|
|
64 public function __construct($task = null, $framed = false)
|
|
|
65 {
|
|
|
66 parent::__construct();
|
|
|
67
|
|
|
68 $this->devel_mode = $this->config->get('devel_mode');
|
|
|
69
|
|
|
70 $this->set_env('task', $task);
|
|
|
71 $this->set_env('x_frame_options', $this->config->get('x_frame_options', 'sameorigin'));
|
|
|
72 $this->set_env('standard_windows', (bool) $this->config->get('standard_windows'));
|
|
|
73 $this->set_env('locale', $_SESSION['language']);
|
|
|
74 $this->set_env('devel_mode', $this->devel_mode);
|
|
|
75
|
|
|
76 // add cookie info
|
|
|
77 $this->set_env('cookie_domain', ini_get('session.cookie_domain'));
|
|
|
78 $this->set_env('cookie_path', ini_get('session.cookie_path'));
|
|
|
79 $this->set_env('cookie_secure', filter_var(ini_get('session.cookie_secure'), FILTER_VALIDATE_BOOLEAN));
|
|
|
80
|
|
|
81 // load the correct skin (in case user-defined)
|
|
|
82 $skin = $this->config->get('skin');
|
|
|
83 $this->set_skin($skin);
|
|
|
84 $this->set_env('skin', $skin);
|
|
|
85
|
|
|
86 $this->set_assets_path($this->config->get('assets_path'), $this->config->get('assets_dir'));
|
|
|
87
|
|
|
88 if (!empty($_REQUEST['_extwin']))
|
|
|
89 $this->set_env('extwin', 1);
|
|
|
90 if ($this->framed || $framed)
|
|
|
91 $this->set_env('framed', 1);
|
|
|
92
|
|
|
93 $lic = <<<EOF
|
|
|
94 /*
|
|
|
95 @licstart The following is the entire license notice for the
|
|
|
96 JavaScript code in this page.
|
|
|
97
|
|
|
98 Copyright (C) 2005-2014 The Roundcube Dev Team
|
|
|
99
|
|
|
100 The JavaScript code in this page is free software: you can redistribute
|
|
|
101 it and/or modify it under the terms of the GNU General Public License
|
|
|
102 as published by the Free Software Foundation, either version 3 of
|
|
|
103 the License, or (at your option) any later version.
|
|
|
104
|
|
|
105 The code is distributed WITHOUT ANY WARRANTY; without even the implied
|
|
|
106 warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
107 See the GNU GPL for more details.
|
|
|
108
|
|
|
109 @licend The above is the entire license notice
|
|
|
110 for the JavaScript code in this page.
|
|
|
111 */
|
|
|
112 EOF;
|
|
|
113 // add common javascripts
|
|
|
114 $this->add_script($lic, 'head_top');
|
|
|
115 $this->add_script('var '.self::JS_OBJECT_NAME.' = new rcube_webmail();', 'head_top');
|
|
|
116
|
|
|
117 // don't wait for page onload. Call init at the bottom of the page (delayed)
|
|
|
118 $this->add_script(self::JS_OBJECT_NAME.'.init();', 'docready');
|
|
|
119
|
|
|
120 $this->scripts_path = 'program/js/';
|
|
|
121 $this->include_script('jquery.min.js');
|
|
|
122 $this->include_script('common.js');
|
|
|
123 $this->include_script('app.js');
|
|
|
124
|
|
|
125 // register common UI objects
|
|
|
126 $this->add_handlers(array(
|
|
|
127 'loginform' => array($this, 'login_form'),
|
|
|
128 'preloader' => array($this, 'preloader'),
|
|
|
129 'username' => array($this, 'current_username'),
|
|
|
130 'message' => array($this, 'message_container'),
|
|
|
131 'charsetselector' => array($this, 'charset_selector'),
|
|
|
132 'aboutcontent' => array($this, 'about_content'),
|
|
|
133 ));
|
|
|
134 }
|
|
|
135
|
|
|
136 /**
|
|
|
137 * Set environment variable
|
|
|
138 *
|
|
|
139 * @param string $name Property name
|
|
|
140 * @param mixed $value Property value
|
|
|
141 * @param boolean $addtojs True if this property should be added
|
|
|
142 * to client environment
|
|
|
143 */
|
|
|
144 public function set_env($name, $value, $addtojs = true)
|
|
|
145 {
|
|
|
146 $this->env[$name] = $value;
|
|
|
147
|
|
|
148 if ($addtojs || isset($this->js_env[$name])) {
|
|
|
149 $this->js_env[$name] = $value;
|
|
|
150 }
|
|
|
151 }
|
|
|
152
|
|
|
153 /**
|
|
|
154 * Parse and set assets path
|
|
|
155 *
|
|
|
156 * @param string $path Assets path URL (relative or absolute)
|
|
|
157 * @param string $fs_dif Assets path in filesystem
|
|
|
158 */
|
|
|
159 public function set_assets_path($path, $fs_dir = null)
|
|
|
160 {
|
|
|
161 if (empty($path)) {
|
|
|
162 return;
|
|
|
163 }
|
|
|
164
|
|
|
165 $path = rtrim($path, '/') . '/';
|
|
|
166
|
|
|
167 // handle relative assets path
|
|
|
168 if (!preg_match('|^https?://|', $path) && $path[0] != '/') {
|
|
|
169 // save the path to search for asset files later
|
|
|
170 $this->assets_dir = $path;
|
|
|
171
|
|
|
172 $base = preg_replace('/[?#&].*$/', '', $_SERVER['REQUEST_URI']);
|
|
|
173 $base = rtrim($base, '/');
|
|
|
174
|
|
|
175 // remove url token if exists
|
|
|
176 if ($len = intval($this->config->get('use_secure_urls'))) {
|
|
|
177 $_base = explode('/', $base);
|
|
|
178 $last = count($_base) - 1;
|
|
|
179 $length = $len > 1 ? $len : 16; // as in rcube::get_secure_url_token()
|
|
|
180
|
|
|
181 // we can't use real token here because it
|
|
|
182 // does not exists in unauthenticated state,
|
|
|
183 // hope this will not produce false-positive matches
|
|
|
184 if ($last > -1 && preg_match('/^[a-f0-9]{' . $length . '}$/', $_base[$last])) {
|
|
|
185 $path = '../' . $path;
|
|
|
186 }
|
|
|
187 }
|
|
|
188 }
|
|
|
189
|
|
|
190 // set filesystem path for assets
|
|
|
191 if ($fs_dir) {
|
|
|
192 if ($fs_dir[0] != '/') {
|
|
|
193 $fs_dir = realpath(RCUBE_INSTALL_PATH . $fs_dir);
|
|
|
194 }
|
|
|
195 // ensure the path ends with a slash
|
|
|
196 $this->assets_dir = rtrim($fs_dir, '/') . '/';
|
|
|
197 }
|
|
|
198
|
|
|
199 $this->assets_path = $path;
|
|
|
200 $this->set_env('assets_path', $path);
|
|
|
201 }
|
|
|
202
|
|
|
203 /**
|
|
|
204 * Getter for the current page title
|
|
|
205 *
|
|
|
206 * @return string The page title
|
|
|
207 */
|
|
|
208 protected function get_pagetitle()
|
|
|
209 {
|
|
|
210 if (!empty($this->pagetitle)) {
|
|
|
211 $title = $this->pagetitle;
|
|
|
212 }
|
|
|
213 else if ($this->env['task'] == 'login') {
|
|
|
214 $title = $this->app->gettext(array(
|
|
|
215 'name' => 'welcome',
|
|
|
216 'vars' => array('product' => $this->config->get('product_name')
|
|
|
217 )));
|
|
|
218 }
|
|
|
219 else {
|
|
|
220 $title = ucfirst($this->env['task']);
|
|
|
221 }
|
|
|
222
|
|
|
223 return $title;
|
|
|
224 }
|
|
|
225
|
|
|
226 /**
|
|
|
227 * Set skin
|
|
|
228 *
|
|
|
229 * @param string $skin Skin name
|
|
|
230 *
|
|
|
231 * @return bool True if the skin exist and is readable, False otherwise
|
|
|
232 */
|
|
|
233 public function set_skin($skin)
|
|
|
234 {
|
|
|
235 // Sanity check to prevent from path traversal vulnerability (#1490620)
|
|
|
236 if (strpos($skin, '/') !== false || strpos($skin, "\\") !== false) {
|
|
|
237 rcube::raise_error(array(
|
|
|
238 'file' => __FILE__,
|
|
|
239 'line' => __LINE__,
|
|
|
240 'message' => 'Invalid skin name'
|
|
|
241 ), true, false);
|
|
|
242
|
|
|
243 return false;
|
|
|
244 }
|
|
|
245
|
|
|
246 $valid = false;
|
|
|
247 $path = RCUBE_INSTALL_PATH . 'skins/';
|
|
|
248
|
|
|
249 if (!empty($skin) && is_dir($path . $skin) && is_readable($path . $skin)) {
|
|
|
250 $skin_path = 'skins/' . $skin;
|
|
|
251 $valid = true;
|
|
|
252 }
|
|
|
253 else {
|
|
|
254 $skin_path = $this->config->get('skin_path');
|
|
|
255 if (!$skin_path) {
|
|
|
256 $skin_path = 'skins/' . rcube_config::DEFAULT_SKIN;
|
|
|
257 }
|
|
|
258 $valid = !$skin;
|
|
|
259 }
|
|
|
260
|
|
|
261 $skin_path = rtrim($skin_path, '/');
|
|
|
262
|
|
|
263 $this->config->set('skin_path', $skin_path);
|
|
|
264 $this->base_path = $skin_path;
|
|
|
265
|
|
|
266 // register skin path(s)
|
|
|
267 $this->skin_paths = array();
|
|
|
268 $this->load_skin($skin_path);
|
|
|
269
|
|
|
270 return $valid;
|
|
|
271 }
|
|
|
272
|
|
|
273 /**
|
|
|
274 * Helper method to recursively read skin meta files and register search paths
|
|
|
275 */
|
|
|
276 private function load_skin($skin_path)
|
|
|
277 {
|
|
|
278 $this->skin_paths[] = $skin_path;
|
|
|
279
|
|
|
280 // read meta file and check for dependencies
|
|
|
281 $meta = @file_get_contents(RCUBE_INSTALL_PATH . $skin_path . '/meta.json');
|
|
|
282 $meta = @json_decode($meta, true);
|
|
|
283
|
|
|
284 $meta['path'] = $skin_path;
|
|
|
285 $path_elements = explode('/', $skin_path);
|
|
|
286 $skin_id = end($path_elements);
|
|
|
287
|
|
|
288 if (!$meta['name']) {
|
|
|
289 $meta['name'] = $skin_id;
|
|
|
290 }
|
|
|
291
|
|
|
292 $this->skins[$skin_id] = $meta;
|
|
|
293
|
|
|
294 if ($meta['extends']) {
|
|
|
295 $path = RCUBE_INSTALL_PATH . 'skins/';
|
|
|
296 if (is_dir($path . $meta['extends']) && is_readable($path . $meta['extends'])) {
|
|
|
297 $this->load_skin('skins/' . $meta['extends']);
|
|
|
298 }
|
|
|
299 }
|
|
|
300 }
|
|
|
301
|
|
|
302 /**
|
|
|
303 * Check if a specific template exists
|
|
|
304 *
|
|
|
305 * @param string $name Template name
|
|
|
306 *
|
|
|
307 * @return boolean True if template exists
|
|
|
308 */
|
|
|
309 public function template_exists($name)
|
|
|
310 {
|
|
|
311 foreach ($this->skin_paths as $skin_path) {
|
|
|
312 $filename = RCUBE_INSTALL_PATH . $skin_path . '/templates/' . $name . '.html';
|
|
|
313 if ((is_file($filename) && is_readable($filename))
|
|
|
314 || ($this->deprecated_templates[$name] && $this->template_exists($this->deprecated_templates[$name]))
|
|
|
315 ) {
|
|
|
316 return true;
|
|
|
317 }
|
|
|
318 }
|
|
|
319
|
|
|
320 return false;
|
|
|
321 }
|
|
|
322
|
|
|
323 /**
|
|
|
324 * Find the given file in the current skin path stack
|
|
|
325 *
|
|
|
326 * @param string $file File name/path to resolve (starting with /)
|
|
|
327 * @param string &$skin_path Reference to the base path of the matching skin
|
|
|
328 * @param string $add_path Additional path to search in
|
|
|
329 *
|
|
|
330 * @return mixed Relative path to the requested file or False if not found
|
|
|
331 */
|
|
|
332 public function get_skin_file($file, &$skin_path = null, $add_path = null)
|
|
|
333 {
|
|
|
334 $skin_paths = $this->skin_paths;
|
|
|
335 if ($add_path) {
|
|
|
336 array_unshift($skin_paths, $add_path);
|
|
|
337 }
|
|
|
338
|
|
|
339 foreach ($skin_paths as $skin_path) {
|
|
|
340 $path = realpath(RCUBE_INSTALL_PATH . $skin_path . $file);
|
|
|
341
|
|
|
342 if ($path && is_file($path)) {
|
|
|
343 return $skin_path . $file;
|
|
|
344 }
|
|
|
345
|
|
|
346 if ($this->assets_dir != RCUBE_INSTALL_PATH) {
|
|
|
347 $path = realpath($this->assets_dir . $skin_path . $file);
|
|
|
348
|
|
|
349 if ($path && is_file($path)) {
|
|
|
350 return $skin_path . $file;
|
|
|
351 }
|
|
|
352 }
|
|
|
353 }
|
|
|
354
|
|
|
355 return false;
|
|
|
356 }
|
|
|
357
|
|
|
358 /**
|
|
|
359 * Register a GUI object to the client script
|
|
|
360 *
|
|
|
361 * @param string $obj Object name
|
|
|
362 * @param string $id Object ID
|
|
|
363 */
|
|
|
364 public function add_gui_object($obj, $id)
|
|
|
365 {
|
|
|
366 $this->add_script(self::JS_OBJECT_NAME.".gui_object('$obj', '$id');");
|
|
|
367 }
|
|
|
368
|
|
|
369 /**
|
|
|
370 * Call a client method
|
|
|
371 *
|
|
|
372 * @param string Method to call
|
|
|
373 * @param ... Additional arguments
|
|
|
374 */
|
|
|
375 public function command()
|
|
|
376 {
|
|
|
377 $cmd = func_get_args();
|
|
|
378 if (strpos($cmd[0], 'plugin.') !== false)
|
|
|
379 $this->js_commands[] = array('triggerEvent', $cmd[0], $cmd[1]);
|
|
|
380 else
|
|
|
381 $this->js_commands[] = $cmd;
|
|
|
382 }
|
|
|
383
|
|
|
384 /**
|
|
|
385 * Add a localized label to the client environment
|
|
|
386 */
|
|
|
387 public function add_label()
|
|
|
388 {
|
|
|
389 $args = func_get_args();
|
|
|
390
|
|
|
391 if (count($args) == 1 && is_array($args[0])) {
|
|
|
392 $args = $args[0];
|
|
|
393 }
|
|
|
394
|
|
|
395 foreach ($args as $name) {
|
|
|
396 $this->js_labels[$name] = $this->app->gettext($name);
|
|
|
397 }
|
|
|
398 }
|
|
|
399
|
|
|
400 /**
|
|
|
401 * Invoke display_message command
|
|
|
402 *
|
|
|
403 * @param string $message Message to display
|
|
|
404 * @param string $type Message type [notice|confirm|error]
|
|
|
405 * @param array $vars Key-value pairs to be replaced in localized text
|
|
|
406 * @param boolean $override Override last set message
|
|
|
407 * @param int $timeout Message display time in seconds
|
|
|
408 *
|
|
|
409 * @uses self::command()
|
|
|
410 */
|
|
|
411 public function show_message($message, $type='notice', $vars=null, $override=true, $timeout=0)
|
|
|
412 {
|
|
|
413 if ($override || !$this->message) {
|
|
|
414 if ($this->app->text_exists($message)) {
|
|
|
415 if (!empty($vars))
|
|
|
416 $vars = array_map(array('rcube','Q'), $vars);
|
|
|
417 $msgtext = $this->app->gettext(array('name' => $message, 'vars' => $vars));
|
|
|
418 }
|
|
|
419 else
|
|
|
420 $msgtext = $message;
|
|
|
421
|
|
|
422 $this->message = $message;
|
|
|
423 $this->command('display_message', $msgtext, $type, $timeout * 1000);
|
|
|
424 }
|
|
|
425 }
|
|
|
426
|
|
|
427 /**
|
|
|
428 * Delete all stored env variables and commands
|
|
|
429 *
|
|
|
430 * @param bool $all Reset all env variables (including internal)
|
|
|
431 */
|
|
|
432 public function reset($all = false)
|
|
|
433 {
|
|
|
434 $framed = $this->framed;
|
|
|
435 $env = $all ? null : array_intersect_key($this->env, array('extwin'=>1, 'framed'=>1));
|
|
|
436
|
|
|
437 parent::reset();
|
|
|
438
|
|
|
439 // let some env variables survive
|
|
|
440 $this->env = $this->js_env = $env;
|
|
|
441 $this->framed = $framed || $this->env['framed'];
|
|
|
442 $this->js_labels = array();
|
|
|
443 $this->js_commands = array();
|
|
|
444 $this->script_files = array();
|
|
|
445 $this->scripts = array();
|
|
|
446 $this->header = '';
|
|
|
447 $this->footer = '';
|
|
|
448 $this->body = '';
|
|
|
449
|
|
|
450 // load defaults
|
|
|
451 if (!$all) {
|
|
|
452 $this->__construct();
|
|
|
453 }
|
|
|
454 }
|
|
|
455
|
|
|
456 /**
|
|
|
457 * Redirect to a certain url
|
|
|
458 *
|
|
|
459 * @param mixed $p Either a string with the action or url parameters as key-value pairs
|
|
|
460 * @param int $delay Delay in seconds
|
|
|
461 * @param bool $secure Redirect to secure location (see rcmail::url())
|
|
|
462 */
|
|
|
463 public function redirect($p = array(), $delay = 1, $secure = false)
|
|
|
464 {
|
|
|
465 if ($this->env['extwin'])
|
|
|
466 $p['extwin'] = 1;
|
|
|
467 $location = $this->app->url($p, false, false, $secure);
|
|
|
468 header('Location: ' . $location);
|
|
|
469 exit;
|
|
|
470 }
|
|
|
471
|
|
|
472 /**
|
|
|
473 * Send the request output to the client.
|
|
|
474 * This will either parse a skin tempalte or send an AJAX response
|
|
|
475 *
|
|
|
476 * @param string $templ Template name
|
|
|
477 * @param boolean $exit True if script should terminate (default)
|
|
|
478 */
|
|
|
479 public function send($templ = null, $exit = true)
|
|
|
480 {
|
|
|
481 if ($templ != 'iframe') {
|
|
|
482 // prevent from endless loops
|
|
|
483 if ($exit != 'recur' && $this->app->plugins->is_processing('render_page')) {
|
|
|
484 rcube::raise_error(array('code' => 505, 'type' => 'php',
|
|
|
485 'file' => __FILE__, 'line' => __LINE__,
|
|
|
486 'message' => 'Recursion alert: ignoring output->send()'), true, false);
|
|
|
487 return;
|
|
|
488 }
|
|
|
489 $this->parse($templ, false);
|
|
|
490 }
|
|
|
491 else {
|
|
|
492 $this->framed = true;
|
|
|
493 $this->write();
|
|
|
494 }
|
|
|
495
|
|
|
496 // set output asap
|
|
|
497 ob_flush();
|
|
|
498 flush();
|
|
|
499
|
|
|
500 if ($exit) {
|
|
|
501 exit;
|
|
|
502 }
|
|
|
503 }
|
|
|
504
|
|
|
505 /**
|
|
|
506 * Process template and write to stdOut
|
|
|
507 *
|
|
|
508 * @param string $template HTML template content
|
|
|
509 */
|
|
|
510 public function write($template = '')
|
|
|
511 {
|
|
|
512 if (!empty($this->script_files)) {
|
|
|
513 $this->set_env('request_token', $this->app->get_request_token());
|
|
|
514 }
|
|
|
515
|
|
|
516 $commands = $this->get_js_commands($framed);
|
|
|
517
|
|
|
518 // if all js commands go to parent window we can ignore all
|
|
|
519 // script files and skip rcube_webmail initialization (#1489792)
|
|
|
520 if ($framed) {
|
|
|
521 $this->scripts = array();
|
|
|
522 $this->script_files = array();
|
|
|
523 $this->header = '';
|
|
|
524 $this->footer = '';
|
|
|
525 }
|
|
|
526
|
|
|
527 // write all javascript commands
|
|
|
528 $this->add_script($commands, 'head_top');
|
|
|
529
|
|
|
530 // allow (legal) iframe content to be loaded
|
|
|
531 $iframe = $this->framed || $this->env['framed'];
|
|
|
532 if (!headers_sent() && $iframe && ($xopt = $this->app->config->get('x_frame_options', 'sameorigin'))) {
|
|
|
533 if (strtolower($xopt) != 'sameorigin') {
|
|
|
534 header('X-Frame-Options: sameorigin', true);
|
|
|
535 }
|
|
|
536 }
|
|
|
537
|
|
|
538 // call super method
|
|
|
539 $this->_write($template, $this->config->get('skin_path'));
|
|
|
540 }
|
|
|
541
|
|
|
542 /**
|
|
|
543 * Parse a specific skin template and deliver to stdout (or return)
|
|
|
544 *
|
|
|
545 * @param string $name Template name
|
|
|
546 * @param boolean $exit Exit script
|
|
|
547 * @param boolean $write Don't write to stdout, return parsed content instead
|
|
|
548 *
|
|
|
549 * @link http://php.net/manual/en/function.exit.php
|
|
|
550 */
|
|
|
551 function parse($name = 'main', $exit = true, $write = true)
|
|
|
552 {
|
|
|
553 $plugin = false;
|
|
|
554 $realname = $name;
|
|
|
555 $plugin_skin_paths = array();
|
|
|
556
|
|
|
557 $this->template_name = $realname;
|
|
|
558
|
|
|
559 $temp = explode('.', $name, 2);
|
|
|
560 if (count($temp) > 1) {
|
|
|
561 $plugin = $temp[0];
|
|
|
562 $name = $temp[1];
|
|
|
563 $skin_dir = $plugin . '/skins/' . $this->config->get('skin');
|
|
|
564
|
|
|
565 // apply skin search escalation list to plugin directory
|
|
|
566 foreach ($this->skin_paths as $skin_path) {
|
|
|
567 $plugin_skin_paths[] = $this->app->plugins->url . $plugin . '/' . $skin_path;
|
|
|
568 }
|
|
|
569
|
|
|
570 // add fallback to default skin
|
|
|
571 if (is_dir($this->app->plugins->dir . $plugin . '/skins/default')) {
|
|
|
572 $skin_dir = $plugin . '/skins/default';
|
|
|
573 $plugin_skin_paths[] = $this->app->plugins->url . $skin_dir;
|
|
|
574 }
|
|
|
575
|
|
|
576 // prepend plugin skin paths to search list
|
|
|
577 $this->skin_paths = array_merge($plugin_skin_paths, $this->skin_paths);
|
|
|
578 }
|
|
|
579
|
|
|
580 // find skin template
|
|
|
581 $path = false;
|
|
|
582 foreach ($this->skin_paths as $skin_path) {
|
|
|
583 $path = RCUBE_INSTALL_PATH . "$skin_path/templates/$name.html";
|
|
|
584
|
|
|
585 // fallback to deprecated template names
|
|
|
586 if (!is_readable($path) && ($dname = $this->deprecated_templates[$realname])) {
|
|
|
587 $path = RCUBE_INSTALL_PATH . "$skin_path/templates/$dname.html";
|
|
|
588
|
|
|
589 if (is_readable($path)) {
|
|
|
590 rcube::raise_error(array(
|
|
|
591 'code' => 502, 'file' => __FILE__, 'line' => __LINE__,
|
|
|
592 'message' => "Using deprecated template '$dname' in $skin_path/templates. Please rename to '$realname'"
|
|
|
593 ), true, false);
|
|
|
594 }
|
|
|
595 }
|
|
|
596
|
|
|
597 if (is_readable($path)) {
|
|
|
598 $this->config->set('skin_path', $skin_path);
|
|
|
599 // set base_path to core skin directory (not plugin's skin)
|
|
|
600 $this->base_path = preg_replace('!plugins/\w+/!', '', $skin_path);
|
|
|
601 $skin_dir = preg_replace('!^plugins/!', '', $skin_path);
|
|
|
602 break;
|
|
|
603 }
|
|
|
604 else {
|
|
|
605 $path = false;
|
|
|
606 }
|
|
|
607 }
|
|
|
608
|
|
|
609 // read template file
|
|
|
610 if (!$path || ($templ = @file_get_contents($path)) === false) {
|
|
|
611 rcube::raise_error(array(
|
|
|
612 'code' => 404,
|
|
|
613 'type' => 'php',
|
|
|
614 'line' => __LINE__,
|
|
|
615 'file' => __FILE__,
|
|
|
616 'message' => 'Error loading template for '.$realname
|
|
|
617 ), true, $write);
|
|
|
618
|
|
|
619 $this->skin_paths = array_slice($this->skin_paths, count($plugin_skin_paths));
|
|
|
620 return false;
|
|
|
621 }
|
|
|
622
|
|
|
623 // replace all path references to plugins/... with the configured plugins dir
|
|
|
624 // and /this/ to the current plugin skin directory
|
|
|
625 if ($plugin) {
|
|
|
626 $templ = preg_replace(
|
|
|
627 array('/\bplugins\//', '/(["\']?)\/this\//'),
|
|
|
628 array($this->app->plugins->url, '\\1'.$this->app->plugins->url.$skin_dir.'/'),
|
|
|
629 $templ
|
|
|
630 );
|
|
|
631 }
|
|
|
632
|
|
|
633 // parse for specialtags
|
|
|
634 $output = $this->parse_conditions($templ);
|
|
|
635 $output = $this->parse_xml($output);
|
|
|
636
|
|
|
637 // trigger generic hook where plugins can put additional content to the page
|
|
|
638 $hook = $this->app->plugins->exec_hook("render_page", array('template' => $realname, 'content' => $output));
|
|
|
639
|
|
|
640 // save some memory
|
|
|
641 $output = $hook['content'];
|
|
|
642 unset($hook['content']);
|
|
|
643
|
|
|
644 // remove plugin skin paths from current context
|
|
|
645 $this->skin_paths = array_slice($this->skin_paths, count($plugin_skin_paths));
|
|
|
646
|
|
|
647 if (!$write) {
|
|
|
648 return $this->postrender($output);
|
|
|
649 }
|
|
|
650
|
|
|
651 $this->write(trim($output));
|
|
|
652
|
|
|
653 if ($exit) {
|
|
|
654 exit;
|
|
|
655 }
|
|
|
656 }
|
|
|
657
|
|
|
658 /**
|
|
|
659 * Return executable javascript code for all registered commands
|
|
|
660 */
|
|
|
661 protected function get_js_commands(&$framed = null)
|
|
|
662 {
|
|
|
663 $out = '';
|
|
|
664 $parent_commands = 0;
|
|
|
665 $top_commands = array();
|
|
|
666
|
|
|
667 // these should be always on top,
|
|
|
668 // e.g. hide_message() below depends on env.framed
|
|
|
669 if (!$this->framed && !empty($this->js_env)) {
|
|
|
670 $top_commands[] = array('set_env', $this->js_env);
|
|
|
671 }
|
|
|
672 if (!empty($this->js_labels)) {
|
|
|
673 $top_commands[] = array('add_label', $this->js_labels);
|
|
|
674 }
|
|
|
675
|
|
|
676 // unlock interface after iframe load
|
|
|
677 $unlock = preg_replace('/[^a-z0-9]/i', '', $_REQUEST['_unlock']);
|
|
|
678 if ($this->framed) {
|
|
|
679 $top_commands[] = array('iframe_loaded', $unlock);
|
|
|
680 }
|
|
|
681 else if ($unlock) {
|
|
|
682 $top_commands[] = array('hide_message', $unlock);
|
|
|
683 }
|
|
|
684
|
|
|
685 $commands = array_merge($top_commands, $this->js_commands);
|
|
|
686
|
|
|
687 foreach ($commands as $i => $args) {
|
|
|
688 $method = array_shift($args);
|
|
|
689 $parent = $this->framed || preg_match('/^parent\./', $method);
|
|
|
690
|
|
|
691 foreach ($args as $i => $arg) {
|
|
|
692 $args[$i] = self::json_serialize($arg, $this->devel_mode);
|
|
|
693 }
|
|
|
694
|
|
|
695 if ($parent) {
|
|
|
696 $parent_commands++;
|
|
|
697 $method = preg_replace('/^parent\./', '', $method);
|
|
|
698 $parent_prefix = 'if (window.parent && parent.' . self::JS_OBJECT_NAME . ') parent.';
|
|
|
699 $method = $parent_prefix . self::JS_OBJECT_NAME . '.' . $method;
|
|
|
700 }
|
|
|
701 else {
|
|
|
702 $method = self::JS_OBJECT_NAME . '.' . $method;
|
|
|
703 }
|
|
|
704
|
|
|
705 $out .= sprintf("%s(%s);\n", $method, implode(',', $args));
|
|
|
706 }
|
|
|
707
|
|
|
708 $framed = $parent_prefix && $parent_commands == count($commands);
|
|
|
709
|
|
|
710 // make the output more compact if all commands go to parent window
|
|
|
711 if ($framed) {
|
|
|
712 $out = "if (window.parent && parent." . self::JS_OBJECT_NAME . ") {\n"
|
|
|
713 . str_replace($parent_prefix, "\tparent.", $out)
|
|
|
714 . "}\n";
|
|
|
715 }
|
|
|
716
|
|
|
717 return $out;
|
|
|
718 }
|
|
|
719
|
|
|
720 /**
|
|
|
721 * Make URLs starting with a slash point to skin directory
|
|
|
722 *
|
|
|
723 * @param string $str Input string
|
|
|
724 * @param bool $search_path True if URL should be resolved using the current skin path stack
|
|
|
725 *
|
|
|
726 * @return string URL
|
|
|
727 */
|
|
|
728 public function abs_url($str, $search_path = false)
|
|
|
729 {
|
|
|
730 if ($str[0] == '/') {
|
|
|
731 if ($search_path && ($file_url = $this->get_skin_file($str, $skin_path))) {
|
|
|
732 return $file_url;
|
|
|
733 }
|
|
|
734
|
|
|
735 return $this->base_path . $str;
|
|
|
736 }
|
|
|
737
|
|
|
738 return $str;
|
|
|
739 }
|
|
|
740
|
|
|
741 /**
|
|
|
742 * Show error page and terminate script execution
|
|
|
743 *
|
|
|
744 * @param int $code Error code
|
|
|
745 * @param string $message Error message
|
|
|
746 */
|
|
|
747 public function raise_error($code, $message)
|
|
|
748 {
|
|
|
749 global $__page_content, $ERROR_CODE, $ERROR_MESSAGE;
|
|
|
750
|
|
|
751 $ERROR_CODE = $code;
|
|
|
752 $ERROR_MESSAGE = $message;
|
|
|
753
|
|
|
754 include RCUBE_INSTALL_PATH . 'program/steps/utils/error.inc';
|
|
|
755 exit;
|
|
|
756 }
|
|
|
757
|
|
|
758 /**
|
|
|
759 * Modify path by adding URL prefix if configured
|
|
|
760 */
|
|
|
761 public function asset_url($path)
|
|
|
762 {
|
|
|
763 // iframe content can't be in a different domain
|
|
|
764 // @TODO: check if assests are on a different domain
|
|
|
765
|
|
|
766 if (!$this->assets_path || in_array($path[0], array('?', '/', '.')) || strpos($path, '://')) {
|
|
|
767 return $path;
|
|
|
768 }
|
|
|
769
|
|
|
770 return $this->assets_path . $path;
|
|
|
771 }
|
|
|
772
|
|
|
773
|
|
|
774 /***** Template parsing methods *****/
|
|
|
775
|
|
|
776 /**
|
|
|
777 * Replace all strings ($varname)
|
|
|
778 * with the content of the according global variable.
|
|
|
779 */
|
|
|
780 protected function parse_with_globals($input)
|
|
|
781 {
|
|
|
782 $GLOBALS['__version'] = html::quote(RCMAIL_VERSION);
|
|
|
783 $GLOBALS['__comm_path'] = html::quote($this->app->comm_path);
|
|
|
784 $GLOBALS['__skin_path'] = html::quote($this->base_path);
|
|
|
785
|
|
|
786 return preg_replace_callback('/\$(__[a-z0-9_\-]+)/',
|
|
|
787 array($this, 'globals_callback'), $input);
|
|
|
788 }
|
|
|
789
|
|
|
790 /**
|
|
|
791 * Callback function for preg_replace_callback() in parse_with_globals()
|
|
|
792 */
|
|
|
793 protected function globals_callback($matches)
|
|
|
794 {
|
|
|
795 return $GLOBALS[$matches[1]];
|
|
|
796 }
|
|
|
797
|
|
|
798 /**
|
|
|
799 * Correct absolute paths in images and other tags
|
|
|
800 * add timestamp to .js and .css filename
|
|
|
801 */
|
|
|
802 protected function fix_paths($output)
|
|
|
803 {
|
|
|
804 return preg_replace_callback(
|
|
|
805 '!(src|href|background)=(["\']?)([a-z0-9/_.-]+)(["\'\s>])!i',
|
|
|
806 array($this, 'file_callback'), $output);
|
|
|
807 }
|
|
|
808
|
|
|
809 /**
|
|
|
810 * Callback function for preg_replace_callback in fix_paths()
|
|
|
811 *
|
|
|
812 * @return string Parsed string
|
|
|
813 */
|
|
|
814 protected function file_callback($matches)
|
|
|
815 {
|
|
|
816 $file = $matches[3];
|
|
|
817 $file = preg_replace('!^/this/!', '/', $file);
|
|
|
818
|
|
|
819 // correct absolute paths
|
|
|
820 if ($file[0] == '/') {
|
|
|
821 $file = $this->base_path . $file;
|
|
|
822 }
|
|
|
823
|
|
|
824 // add file modification timestamp
|
|
|
825 if (preg_match('/\.(js|css)$/', $file, $m)) {
|
|
|
826 $file = $this->file_mod($file);
|
|
|
827 }
|
|
|
828
|
|
|
829 return $matches[1] . '=' . $matches[2] . $file . $matches[4];
|
|
|
830 }
|
|
|
831
|
|
|
832 /**
|
|
|
833 * Correct paths of asset files according to assets_path
|
|
|
834 */
|
|
|
835 protected function fix_assets_paths($output)
|
|
|
836 {
|
|
|
837 return preg_replace_callback(
|
|
|
838 '!(src|href|background)=(["\']?)([a-z0-9/_.?=-]+)(["\'\s>])!i',
|
|
|
839 array($this, 'assets_callback'), $output);
|
|
|
840 }
|
|
|
841
|
|
|
842 /**
|
|
|
843 * Callback function for preg_replace_callback in fix_assets_paths()
|
|
|
844 *
|
|
|
845 * @return string Parsed string
|
|
|
846 */
|
|
|
847 protected function assets_callback($matches)
|
|
|
848 {
|
|
|
849 $file = $this->asset_url($matches[3]);
|
|
|
850
|
|
|
851 return $matches[1] . '=' . $matches[2] . $file . $matches[4];
|
|
|
852 }
|
|
|
853
|
|
|
854 /**
|
|
|
855 * Modify file by adding mtime indicator
|
|
|
856 */
|
|
|
857 protected function file_mod($file)
|
|
|
858 {
|
|
|
859 $fs = false;
|
|
|
860 $ext = substr($file, strrpos($file, '.') + 1);
|
|
|
861
|
|
|
862 // use minified file if exists (not in development mode)
|
|
|
863 if (!$this->devel_mode && !preg_match('/\.min\.' . $ext . '$/', $file)) {
|
|
|
864 $minified_file = substr($file, 0, strlen($ext) * -1) . 'min.' . $ext;
|
|
|
865 if ($fs = @filemtime($this->assets_dir . $minified_file)) {
|
|
|
866 return $minified_file . '?s=' . $fs;
|
|
|
867 }
|
|
|
868 }
|
|
|
869
|
|
|
870 if ($fs = @filemtime($this->assets_dir . $file)) {
|
|
|
871 $file .= '?s=' . $fs;
|
|
|
872 }
|
|
|
873
|
|
|
874 return $file;
|
|
|
875 }
|
|
|
876
|
|
|
877 /**
|
|
|
878 * Public wrapper to dipp into template parsing.
|
|
|
879 *
|
|
|
880 * @param string $input Template content
|
|
|
881 *
|
|
|
882 * @return string
|
|
|
883 * @uses rcmail_output_html::parse_xml()
|
|
|
884 * @since 0.1-rc1
|
|
|
885 */
|
|
|
886 public function just_parse($input)
|
|
|
887 {
|
|
|
888 $input = $this->parse_conditions($input);
|
|
|
889 $input = $this->parse_xml($input);
|
|
|
890 $input = $this->postrender($input);
|
|
|
891
|
|
|
892 return $input;
|
|
|
893 }
|
|
|
894
|
|
|
895 /**
|
|
|
896 * Parse for conditional tags
|
|
|
897 */
|
|
|
898 protected function parse_conditions($input)
|
|
|
899 {
|
|
|
900 $matches = preg_split('/<roundcube:(if|elseif|else|endif)\s+([^>]+)>\n?/is', $input, 2, PREG_SPLIT_DELIM_CAPTURE);
|
|
|
901 if ($matches && count($matches) == 4) {
|
|
|
902 if (preg_match('/^(else|endif)$/i', $matches[1])) {
|
|
|
903 return $matches[0] . $this->parse_conditions($matches[3]);
|
|
|
904 }
|
|
|
905
|
|
|
906 $attrib = html::parse_attrib_string($matches[2]);
|
|
|
907
|
|
|
908 if (isset($attrib['condition'])) {
|
|
|
909 $condmet = $this->check_condition($attrib['condition']);
|
|
|
910 $submatches = preg_split('/<roundcube:(elseif|else|endif)\s+([^>]+)>\n?/is', $matches[3], 2, PREG_SPLIT_DELIM_CAPTURE);
|
|
|
911
|
|
|
912 if ($condmet) {
|
|
|
913 $result = $submatches[0];
|
|
|
914 if ($submatches[1] != 'endif') {
|
|
|
915 $result .= preg_replace('/.*<roundcube:endif\s+[^>]+>\n?/Uis', '', $submatches[3], 1);
|
|
|
916 }
|
|
|
917 else {
|
|
|
918 $result .= $submatches[3];
|
|
|
919 }
|
|
|
920 }
|
|
|
921 else {
|
|
|
922 $result = "<roundcube:$submatches[1] $submatches[2]>" . $submatches[3];
|
|
|
923 }
|
|
|
924
|
|
|
925 return $matches[0] . $this->parse_conditions($result);
|
|
|
926 }
|
|
|
927
|
|
|
928 rcube::raise_error(array(
|
|
|
929 'code' => 500, 'line' => __LINE__, 'file' => __FILE__,
|
|
|
930 'message' => "Unable to parse conditional tag " . $matches[2]
|
|
|
931 ), true, false);
|
|
|
932 }
|
|
|
933
|
|
|
934 return $input;
|
|
|
935 }
|
|
|
936
|
|
|
937 /**
|
|
|
938 * Determines if a given condition is met
|
|
|
939 *
|
|
|
940 * @param string $condition Condition statement
|
|
|
941 *
|
|
|
942 * @return boolean True if condition is met, False if not
|
|
|
943 * @todo Extend this to allow real conditions, not just "set"
|
|
|
944 */
|
|
|
945 protected function check_condition($condition)
|
|
|
946 {
|
|
|
947 return $this->eval_expression($condition);
|
|
|
948 }
|
|
|
949
|
|
|
950 /**
|
|
|
951 * Inserts hidden field with CSRF-prevention-token into POST forms
|
|
|
952 */
|
|
|
953 protected function alter_form_tag($matches)
|
|
|
954 {
|
|
|
955 $out = $matches[0];
|
|
|
956 $attrib = html::parse_attrib_string($matches[1]);
|
|
|
957
|
|
|
958 if (strtolower($attrib['method']) == 'post') {
|
|
|
959 $hidden = new html_hiddenfield(array('name' => '_token', 'value' => $this->app->get_request_token()));
|
|
|
960 $out .= "\n" . $hidden->show();
|
|
|
961 }
|
|
|
962
|
|
|
963 return $out;
|
|
|
964 }
|
|
|
965
|
|
|
966 /**
|
|
|
967 * Parse & evaluate a given expression and return its result.
|
|
|
968 *
|
|
|
969 * @param string $expression Expression statement
|
|
|
970 *
|
|
|
971 * @return mixed Expression result
|
|
|
972 */
|
|
|
973 protected function eval_expression($expression)
|
|
|
974 {
|
|
|
975 $expression = preg_replace(
|
|
|
976 array(
|
|
|
977 '/session:([a-z0-9_]+)/i',
|
|
|
978 '/config:([a-z0-9_]+)(:([a-z0-9_]+))?/i',
|
|
|
979 '/env:([a-z0-9_]+)/i',
|
|
|
980 '/request:([a-z0-9_]+)/i',
|
|
|
981 '/cookie:([a-z0-9_]+)/i',
|
|
|
982 '/browser:([a-z0-9_]+)/i',
|
|
|
983 '/template:name/i',
|
|
|
984 ),
|
|
|
985 array(
|
|
|
986 "\$_SESSION['\\1']",
|
|
|
987 "\$this->app->config->get('\\1',rcube_utils::get_boolean('\\3'))",
|
|
|
988 "\$this->env['\\1']",
|
|
|
989 "rcube_utils::get_input_value('\\1', rcube_utils::INPUT_GPC)",
|
|
|
990 "\$_COOKIE['\\1']",
|
|
|
991 "\$this->browser->{'\\1'}",
|
|
|
992 "'{$this->template_name}'",
|
|
|
993 ),
|
|
|
994 $expression
|
|
|
995 );
|
|
|
996
|
|
|
997 // Note: We used create_function() before but it's deprecated in PHP 7.2
|
|
|
998 // and really it was just a wrapper on eval().
|
|
|
999 return eval("return ($expression);");
|
|
|
1000 }
|
|
|
1001
|
|
|
1002 /**
|
|
|
1003 * Search for special tags in input and replace them
|
|
|
1004 * with the appropriate content
|
|
|
1005 *
|
|
|
1006 * @param string $input Input string to parse
|
|
|
1007 *
|
|
|
1008 * @return string Altered input string
|
|
|
1009 * @todo Use DOM-parser to traverse template HTML
|
|
|
1010 * @todo Maybe a cache.
|
|
|
1011 */
|
|
|
1012 protected function parse_xml($input)
|
|
|
1013 {
|
|
|
1014 return preg_replace_callback('/<roundcube:([-_a-z]+)\s+((?:[^>]|\\\\>)+)(?<!\\\\)>/Ui', array($this, 'xml_command'), $input);
|
|
|
1015 }
|
|
|
1016
|
|
|
1017 /**
|
|
|
1018 * Callback function for parsing an xml command tag
|
|
|
1019 * and turn it into real html content
|
|
|
1020 *
|
|
|
1021 * @param array $matches Matches array of preg_replace_callback
|
|
|
1022 *
|
|
|
1023 * @return string Tag/Object content
|
|
|
1024 */
|
|
|
1025 protected function xml_command($matches)
|
|
|
1026 {
|
|
|
1027 $command = strtolower($matches[1]);
|
|
|
1028 $attrib = html::parse_attrib_string($matches[2]);
|
|
|
1029
|
|
|
1030 // empty output if required condition is not met
|
|
|
1031 if (!empty($attrib['condition']) && !$this->check_condition($attrib['condition'])) {
|
|
|
1032 return '';
|
|
|
1033 }
|
|
|
1034
|
|
|
1035 // localize title and summary attributes
|
|
|
1036 if ($command != 'button' && !empty($attrib['title']) && $this->app->text_exists($attrib['title'])) {
|
|
|
1037 $attrib['title'] = $this->app->gettext($attrib['title']);
|
|
|
1038 }
|
|
|
1039 if ($command != 'button' && !empty($attrib['summary']) && $this->app->text_exists($attrib['summary'])) {
|
|
|
1040 $attrib['summary'] = $this->app->gettext($attrib['summary']);
|
|
|
1041 }
|
|
|
1042
|
|
|
1043 // execute command
|
|
|
1044 switch ($command) {
|
|
|
1045 // return a button
|
|
|
1046 case 'button':
|
|
|
1047 if ($attrib['name'] || $attrib['command']) {
|
|
|
1048 return $this->button($attrib);
|
|
|
1049 }
|
|
|
1050 break;
|
|
|
1051
|
|
|
1052 // frame
|
|
|
1053 case 'frame':
|
|
|
1054 return $this->frame($attrib);
|
|
|
1055 break;
|
|
|
1056
|
|
|
1057 // show a label
|
|
|
1058 case 'label':
|
|
|
1059 if ($attrib['expression'])
|
|
|
1060 $attrib['name'] = $this->eval_expression($attrib['expression']);
|
|
|
1061
|
|
|
1062 if ($attrib['name'] || $attrib['command']) {
|
|
|
1063 $vars = $attrib + array('product' => $this->config->get('product_name'));
|
|
|
1064 unset($vars['name'], $vars['command']);
|
|
|
1065
|
|
|
1066 $label = $this->app->gettext($attrib + array('vars' => $vars));
|
|
|
1067 $quoting = !empty($attrib['quoting']) ? strtolower($attrib['quoting']) : (rcube_utils::get_boolean((string)$attrib['html']) ? 'no' : '');
|
|
|
1068
|
|
|
1069 // 'noshow' can be used in skins to define new labels
|
|
|
1070 if ($attrib['noshow']) {
|
|
|
1071 return '';
|
|
|
1072 }
|
|
|
1073
|
|
|
1074 switch ($quoting) {
|
|
|
1075 case 'no':
|
|
|
1076 case 'raw':
|
|
|
1077 break;
|
|
|
1078 case 'javascript':
|
|
|
1079 case 'js':
|
|
|
1080 $label = rcube::JQ($label);
|
|
|
1081 break;
|
|
|
1082 default:
|
|
|
1083 $label = html::quote($label);
|
|
|
1084 break;
|
|
|
1085 }
|
|
|
1086
|
|
|
1087 return $label;
|
|
|
1088 }
|
|
|
1089 break;
|
|
|
1090
|
|
|
1091 case 'add_label':
|
|
|
1092 $this->add_label($attrib['name']);
|
|
|
1093 break;
|
|
|
1094
|
|
|
1095 // include a file
|
|
|
1096 case 'include':
|
|
|
1097 $old_base_path = $this->base_path;
|
|
|
1098 if (!empty($attrib['skin_path'])) $attrib['skinpath'] = $attrib['skin_path'];
|
|
|
1099 if ($path = $this->get_skin_file($attrib['file'], $skin_path, $attrib['skinpath'])) {
|
|
|
1100 // set base_path to core skin directory (not plugin's skin)
|
|
|
1101 $this->base_path = preg_replace('!plugins/\w+/!', '', $skin_path);
|
|
|
1102 $path = realpath(RCUBE_INSTALL_PATH . $path);
|
|
|
1103 }
|
|
|
1104
|
|
|
1105 if (is_readable($path)) {
|
|
|
1106 if ($this->config->get('skin_include_php')) {
|
|
|
1107 $incl = $this->include_php($path);
|
|
|
1108 }
|
|
|
1109 else {
|
|
|
1110 $incl = file_get_contents($path);
|
|
|
1111 }
|
|
|
1112 $incl = $this->parse_conditions($incl);
|
|
|
1113 $incl = $this->parse_xml($incl);
|
|
|
1114 $incl = $this->fix_paths($incl);
|
|
|
1115 $this->base_path = $old_base_path;
|
|
|
1116 return $incl;
|
|
|
1117 }
|
|
|
1118 break;
|
|
|
1119
|
|
|
1120 case 'plugin.include':
|
|
|
1121 $hook = $this->app->plugins->exec_hook("template_plugin_include", $attrib);
|
|
|
1122 return $hook['content'];
|
|
|
1123
|
|
|
1124 // define a container block
|
|
|
1125 case 'container':
|
|
|
1126 if ($attrib['name'] && $attrib['id']) {
|
|
|
1127 $this->command('gui_container', $attrib['name'], $attrib['id']);
|
|
|
1128 // let plugins insert some content here
|
|
|
1129 $hook = $this->app->plugins->exec_hook("template_container", $attrib);
|
|
|
1130 return $hook['content'];
|
|
|
1131 }
|
|
|
1132 break;
|
|
|
1133
|
|
|
1134 // return code for a specific application object
|
|
|
1135 case 'object':
|
|
|
1136 $object = strtolower($attrib['name']);
|
|
|
1137 $content = '';
|
|
|
1138
|
|
|
1139 // we are calling a class/method
|
|
|
1140 if (($handler = $this->object_handlers[$object]) && is_array($handler)) {
|
|
|
1141 if (is_callable($handler)) {
|
|
|
1142 // We assume that objects with src attribute are internal (in most
|
|
|
1143 // cases this is a watermark frame). We need this to make sure assets_path
|
|
|
1144 // is added to the internal assets paths
|
|
|
1145 $external = empty($attrib['src']);
|
|
|
1146 $content = call_user_func($handler, $attrib);
|
|
|
1147 }
|
|
|
1148 }
|
|
|
1149 // execute object handler function
|
|
|
1150 else if (function_exists($handler)) {
|
|
|
1151 $content = call_user_func($handler, $attrib);
|
|
|
1152 }
|
|
|
1153 else if ($object == 'doctype') {
|
|
|
1154 $content = html::doctype($attrib['value']);
|
|
|
1155 }
|
|
|
1156 else if ($object == 'logo') {
|
|
|
1157 $attrib += array('alt' => $this->xml_command(array('', 'object', 'name="productname"')));
|
|
|
1158
|
|
|
1159 if ($logo = $this->config->get('skin_logo')) {
|
|
|
1160 if (is_array($logo)) {
|
|
|
1161 if ($template_logo = $logo[$this->template_name]) {
|
|
|
1162 $attrib['src'] = $template_logo;
|
|
|
1163 }
|
|
|
1164 elseif ($template_logo = $logo['*']) {
|
|
|
1165 $attrib['src'] = $template_logo;
|
|
|
1166 }
|
|
|
1167 }
|
|
|
1168 else {
|
|
|
1169 $attrib['src'] = $logo;
|
|
|
1170 }
|
|
|
1171 }
|
|
|
1172
|
|
|
1173 $content = html::img($attrib);
|
|
|
1174 }
|
|
|
1175 else if ($object == 'productname') {
|
|
|
1176 $name = $this->config->get('product_name', 'Roundcube Webmail');
|
|
|
1177 $content = html::quote($name);
|
|
|
1178 }
|
|
|
1179 else if ($object == 'version') {
|
|
|
1180 $ver = (string)RCMAIL_VERSION;
|
|
|
1181 if (is_file(RCUBE_INSTALL_PATH . '.svn/entries')) {
|
|
|
1182 if (preg_match('/Revision:\s(\d+)/', @shell_exec('svn info'), $regs))
|
|
|
1183 $ver .= ' [SVN r'.$regs[1].']';
|
|
|
1184 }
|
|
|
1185 else if (is_file(RCUBE_INSTALL_PATH . '.git/index')) {
|
|
|
1186 if (preg_match('/Date:\s+([^\n]+)/', @shell_exec('git log -1'), $regs)) {
|
|
|
1187 if ($date = date('Ymd.Hi', strtotime($regs[1]))) {
|
|
|
1188 $ver .= ' [GIT '.$date.']';
|
|
|
1189 }
|
|
|
1190 }
|
|
|
1191 }
|
|
|
1192 $content = html::quote($ver);
|
|
|
1193 }
|
|
|
1194 else if ($object == 'steptitle') {
|
|
|
1195 $content = html::quote($this->get_pagetitle());
|
|
|
1196 }
|
|
|
1197 else if ($object == 'pagetitle') {
|
|
|
1198 if ($this->devel_mode && !empty($_SESSION['username']))
|
|
|
1199 $title = $_SESSION['username'].' :: ';
|
|
|
1200 else if ($prod_name = $this->config->get('product_name'))
|
|
|
1201 $title = $prod_name . ' :: ';
|
|
|
1202 else
|
|
|
1203 $title = '';
|
|
|
1204 $title .= $this->get_pagetitle();
|
|
|
1205 $content = html::quote($title);
|
|
|
1206 }
|
|
|
1207
|
|
|
1208 // exec plugin hooks for this template object
|
|
|
1209 $hook = $this->app->plugins->exec_hook("template_object_$object", $attrib + array('content' => $content));
|
|
|
1210
|
|
|
1211 if (strlen($hook['content']) && !empty($external)) {
|
|
|
1212 $object_id = uniqid('TEMPLOBJECT:', true);
|
|
|
1213 $this->objects[$object_id] = $hook['content'];
|
|
|
1214 $hook['content'] = $object_id;
|
|
|
1215 }
|
|
|
1216
|
|
|
1217 return $hook['content'];
|
|
|
1218
|
|
|
1219 // return code for a specified eval expression
|
|
|
1220 case 'exp':
|
|
|
1221 return html::quote($this->eval_expression($attrib['expression']));
|
|
|
1222
|
|
|
1223 // return variable
|
|
|
1224 case 'var':
|
|
|
1225 $var = explode(':', $attrib['name']);
|
|
|
1226 $name = $var[1];
|
|
|
1227 $value = '';
|
|
|
1228
|
|
|
1229 switch ($var[0]) {
|
|
|
1230 case 'env':
|
|
|
1231 $value = $this->env[$name];
|
|
|
1232 break;
|
|
|
1233 case 'config':
|
|
|
1234 $value = $this->config->get($name);
|
|
|
1235 if (is_array($value) && $value[$_SESSION['storage_host']]) {
|
|
|
1236 $value = $value[$_SESSION['storage_host']];
|
|
|
1237 }
|
|
|
1238 break;
|
|
|
1239 case 'request':
|
|
|
1240 $value = rcube_utils::get_input_value($name, rcube_utils::INPUT_GPC);
|
|
|
1241 break;
|
|
|
1242 case 'session':
|
|
|
1243 $value = $_SESSION[$name];
|
|
|
1244 break;
|
|
|
1245 case 'cookie':
|
|
|
1246 $value = htmlspecialchars($_COOKIE[$name]);
|
|
|
1247 break;
|
|
|
1248 case 'browser':
|
|
|
1249 $value = $this->browser->{$name};
|
|
|
1250 break;
|
|
|
1251 }
|
|
|
1252
|
|
|
1253 if (is_array($value)) {
|
|
|
1254 $value = implode(', ', $value);
|
|
|
1255 }
|
|
|
1256
|
|
|
1257 return html::quote($value);
|
|
|
1258
|
|
|
1259 case 'form':
|
|
|
1260 return $this->form_tag($attrib);
|
|
|
1261 }
|
|
|
1262 return '';
|
|
|
1263 }
|
|
|
1264
|
|
|
1265 /**
|
|
|
1266 * Include a specific file and return it's contents
|
|
|
1267 *
|
|
|
1268 * @param string $file File path
|
|
|
1269 *
|
|
|
1270 * @return string Contents of the processed file
|
|
|
1271 */
|
|
|
1272 protected function include_php($file)
|
|
|
1273 {
|
|
|
1274 ob_start();
|
|
|
1275 include $file;
|
|
|
1276 $out = ob_get_contents();
|
|
|
1277 ob_end_clean();
|
|
|
1278
|
|
|
1279 return $out;
|
|
|
1280 }
|
|
|
1281
|
|
|
1282 /**
|
|
|
1283 * Put objects' content back into template output
|
|
|
1284 */
|
|
|
1285 protected function postrender($output)
|
|
|
1286 {
|
|
|
1287 // insert objects' contents
|
|
|
1288 foreach ($this->objects as $key => $val) {
|
|
|
1289 $output = str_replace($key, $val, $output, $count);
|
|
|
1290 if ($count) {
|
|
|
1291 $this->objects[$key] = null;
|
|
|
1292 }
|
|
|
1293 }
|
|
|
1294
|
|
|
1295 // make sure all <form> tags have a valid request token
|
|
|
1296 $output = preg_replace_callback('/<form\s+([^>]+)>/Ui', array($this, 'alter_form_tag'), $output);
|
|
|
1297
|
|
|
1298 return $output;
|
|
|
1299 }
|
|
|
1300
|
|
|
1301 /**
|
|
|
1302 * Create and register a button
|
|
|
1303 *
|
|
|
1304 * @param array $attrib Named button attributes
|
|
|
1305 *
|
|
|
1306 * @return string HTML button
|
|
|
1307 * @todo Remove all inline JS calls and use jQuery instead.
|
|
|
1308 * @todo Remove all sprintf()'s - they are pretty, but also slow.
|
|
|
1309 */
|
|
|
1310 public function button($attrib)
|
|
|
1311 {
|
|
|
1312 static $s_button_count = 100;
|
|
|
1313 static $disabled_actions = null;
|
|
|
1314
|
|
|
1315 // these commands can be called directly via url
|
|
|
1316 $a_static_commands = array('compose', 'list', 'preferences', 'folders', 'identities');
|
|
|
1317
|
|
|
1318 if (!($attrib['command'] || $attrib['name'] || $attrib['href'])) {
|
|
|
1319 return '';
|
|
|
1320 }
|
|
|
1321
|
|
|
1322 // try to find out the button type
|
|
|
1323 if ($attrib['type']) {
|
|
|
1324 $attrib['type'] = strtolower($attrib['type']);
|
|
|
1325 if ($pos = strpos($attrib['type'], '-menuitem')) {
|
|
|
1326 $attrib['type'] = substr($attrib['type'], 0, -9);
|
|
|
1327 $menuitem = true;
|
|
|
1328 }
|
|
|
1329 }
|
|
|
1330 else {
|
|
|
1331 $attrib['type'] = ($attrib['image'] || $attrib['imagepas'] || $attrib['imageact']) ? 'image' : 'link';
|
|
|
1332 }
|
|
|
1333
|
|
|
1334 $command = $attrib['command'];
|
|
|
1335
|
|
|
1336 if ($attrib['task']) {
|
|
|
1337 $element = $command = $attrib['task'] . '.' . $command;
|
|
|
1338 }
|
|
|
1339 else {
|
|
|
1340 $element = ($this->env['task'] ? $this->env['task'] . '.' : '') . $command;
|
|
|
1341 }
|
|
|
1342
|
|
|
1343 if ($disabled_actions === null) {
|
|
|
1344 $disabled_actions = (array) $this->config->get('disabled_actions');
|
|
|
1345 }
|
|
|
1346
|
|
|
1347 // remove buttons for disabled actions
|
|
|
1348 if (in_array($element, $disabled_actions)) {
|
|
|
1349 return '';
|
|
|
1350 }
|
|
|
1351
|
|
|
1352 if (!$attrib['image']) {
|
|
|
1353 $attrib['image'] = $attrib['imagepas'] ? $attrib['imagepas'] : $attrib['imageact'];
|
|
|
1354 }
|
|
|
1355
|
|
|
1356 if (!$attrib['id']) {
|
|
|
1357 $attrib['id'] = sprintf('rcmbtn%d', $s_button_count++);
|
|
|
1358 }
|
|
|
1359 // get localized text for labels and titles
|
|
|
1360 if ($attrib['title']) {
|
|
|
1361 $attrib['title'] = html::quote($this->app->gettext($attrib['title'], $attrib['domain']));
|
|
|
1362 }
|
|
|
1363 if ($attrib['label']) {
|
|
|
1364 $attrib['label'] = html::quote($this->app->gettext($attrib['label'], $attrib['domain']));
|
|
|
1365 }
|
|
|
1366 if ($attrib['alt']) {
|
|
|
1367 $attrib['alt'] = html::quote($this->app->gettext($attrib['alt'], $attrib['domain']));
|
|
|
1368 }
|
|
|
1369
|
|
|
1370 // set accessibility attributes
|
|
|
1371 if (!$attrib['role']) {
|
|
|
1372 $attrib['role'] = 'button';
|
|
|
1373 }
|
|
|
1374 if (!empty($attrib['class']) && !empty($attrib['classact']) || !empty($attrib['imagepas']) && !empty($attrib['imageact'])) {
|
|
|
1375 if (array_key_exists('tabindex', $attrib))
|
|
|
1376 $attrib['data-tabindex'] = $attrib['tabindex'];
|
|
|
1377 $attrib['tabindex'] = '-1'; // disable button by default
|
|
|
1378 $attrib['aria-disabled'] = 'true';
|
|
|
1379 }
|
|
|
1380
|
|
|
1381 // set title to alt attribute for IE browsers
|
|
|
1382 if ($this->browser->ie && !$attrib['title'] && $attrib['alt']) {
|
|
|
1383 $attrib['title'] = $attrib['alt'];
|
|
|
1384 }
|
|
|
1385
|
|
|
1386 // add empty alt attribute for XHTML compatibility
|
|
|
1387 if (!isset($attrib['alt'])) {
|
|
|
1388 $attrib['alt'] = '';
|
|
|
1389 }
|
|
|
1390
|
|
|
1391 // register button in the system
|
|
|
1392 if ($attrib['command']) {
|
|
|
1393 $this->add_script(sprintf(
|
|
|
1394 "%s.register_button('%s', '%s', '%s', '%s', '%s', '%s');",
|
|
|
1395 self::JS_OBJECT_NAME,
|
|
|
1396 $command,
|
|
|
1397 $attrib['id'],
|
|
|
1398 $attrib['type'],
|
|
|
1399 $attrib['imageact'] ? $this->abs_url($attrib['imageact']) : $attrib['classact'],
|
|
|
1400 $attrib['imagesel'] ? $this->abs_url($attrib['imagesel']) : $attrib['classsel'],
|
|
|
1401 $attrib['imageover'] ? $this->abs_url($attrib['imageover']) : ''
|
|
|
1402 ));
|
|
|
1403
|
|
|
1404 // make valid href to specific buttons
|
|
|
1405 if (in_array($attrib['command'], rcmail::$main_tasks)) {
|
|
|
1406 $attrib['href'] = $this->app->url(array('task' => $attrib['command']));
|
|
|
1407 $attrib['onclick'] = sprintf("return %s.command('switch-task','%s',this,event)", self::JS_OBJECT_NAME, $attrib['command']);
|
|
|
1408 }
|
|
|
1409 else if ($attrib['task'] && in_array($attrib['task'], rcmail::$main_tasks)) {
|
|
|
1410 $attrib['href'] = $this->app->url(array('action' => $attrib['command'], 'task' => $attrib['task']));
|
|
|
1411 }
|
|
|
1412 else if (in_array($attrib['command'], $a_static_commands)) {
|
|
|
1413 $attrib['href'] = $this->app->url(array('action' => $attrib['command']));
|
|
|
1414 }
|
|
|
1415 else if (($attrib['command'] == 'permaurl' || $attrib['command'] == 'extwin') && !empty($this->env['permaurl'])) {
|
|
|
1416 $attrib['href'] = $this->env['permaurl'];
|
|
|
1417 }
|
|
|
1418 }
|
|
|
1419
|
|
|
1420 // overwrite attributes
|
|
|
1421 if (!$attrib['href']) {
|
|
|
1422 $attrib['href'] = '#';
|
|
|
1423 }
|
|
|
1424 if ($attrib['task']) {
|
|
|
1425 if ($attrib['classact'])
|
|
|
1426 $attrib['class'] = $attrib['classact'];
|
|
|
1427 }
|
|
|
1428 else if ($command && !$attrib['onclick']) {
|
|
|
1429 $attrib['onclick'] = sprintf(
|
|
|
1430 "return %s.command('%s','%s',this,event)",
|
|
|
1431 self::JS_OBJECT_NAME,
|
|
|
1432 $command,
|
|
|
1433 $attrib['prop']
|
|
|
1434 );
|
|
|
1435 }
|
|
|
1436
|
|
|
1437 $out = '';
|
|
|
1438
|
|
|
1439 // generate image tag
|
|
|
1440 if ($attrib['type'] == 'image') {
|
|
|
1441 $attrib_str = html::attrib_string(
|
|
|
1442 $attrib,
|
|
|
1443 array(
|
|
|
1444 'style', 'class', 'id', 'width', 'height', 'border', 'hspace',
|
|
|
1445 'vspace', 'align', 'alt', 'tabindex', 'title'
|
|
|
1446 )
|
|
|
1447 );
|
|
|
1448 $btn_content = sprintf('<img src="%s"%s />', $this->abs_url($attrib['image']), $attrib_str);
|
|
|
1449 if ($attrib['label']) {
|
|
|
1450 $btn_content .= ' '.$attrib['label'];
|
|
|
1451 }
|
|
|
1452 $link_attrib = array('href', 'onclick', 'onmouseover', 'onmouseout', 'onmousedown', 'onmouseup', 'target');
|
|
|
1453 }
|
|
|
1454 else if ($attrib['type'] == 'link') {
|
|
|
1455 $btn_content = isset($attrib['content']) ? $attrib['content'] : ($attrib['label'] ? $attrib['label'] : $attrib['command']);
|
|
|
1456 $link_attrib = array_merge(html::$common_attrib, array('href', 'onclick', 'tabindex', 'target'));
|
|
|
1457 if ($attrib['innerclass'])
|
|
|
1458 $btn_content = html::span($attrib['innerclass'], $btn_content);
|
|
|
1459 }
|
|
|
1460 else if ($attrib['type'] == 'input') {
|
|
|
1461 $attrib['type'] = 'button';
|
|
|
1462
|
|
|
1463 if ($attrib['label']) {
|
|
|
1464 $attrib['value'] = $attrib['label'];
|
|
|
1465 }
|
|
|
1466 if ($attrib['command']) {
|
|
|
1467 $attrib['disabled'] = 'disabled';
|
|
|
1468 }
|
|
|
1469
|
|
|
1470 $out = html::tag('input', $attrib, null, array('type', 'value', 'onclick', 'id', 'class', 'style', 'tabindex', 'disabled'));
|
|
|
1471 }
|
|
|
1472
|
|
|
1473 // generate html code for button
|
|
|
1474 if ($btn_content) {
|
|
|
1475 $attrib_str = html::attrib_string($attrib, $link_attrib);
|
|
|
1476 $out = sprintf('<a%s>%s</a>', $attrib_str, $btn_content);
|
|
|
1477 }
|
|
|
1478
|
|
|
1479 if ($attrib['wrapper']) {
|
|
|
1480 $out = html::tag($attrib['wrapper'], null, $out);
|
|
|
1481 }
|
|
|
1482
|
|
|
1483 if ($menuitem) {
|
|
|
1484 $class = $attrib['menuitem-class'] ? ' class="' . $attrib['menuitem-class'] . '"' : '';
|
|
|
1485 $out = '<li role="menuitem"' . $class . '>' . $out . '</li>';
|
|
|
1486 }
|
|
|
1487
|
|
|
1488 return $out;
|
|
|
1489 }
|
|
|
1490
|
|
|
1491 /**
|
|
|
1492 * Link an external script file
|
|
|
1493 *
|
|
|
1494 * @param string $file File URL
|
|
|
1495 * @param string $position Target position [head|foot]
|
|
|
1496 */
|
|
|
1497 public function include_script($file, $position='head')
|
|
|
1498 {
|
|
|
1499 if (!preg_match('|^https?://|i', $file) && $file[0] != '/') {
|
|
|
1500 $file = $this->file_mod($this->scripts_path . $file);
|
|
|
1501 }
|
|
|
1502
|
|
|
1503 if (!is_array($this->script_files[$position])) {
|
|
|
1504 $this->script_files[$position] = array();
|
|
|
1505 }
|
|
|
1506
|
|
|
1507 if (!in_array($file, $this->script_files[$position])) {
|
|
|
1508 $this->script_files[$position][] = $file;
|
|
|
1509 }
|
|
|
1510 }
|
|
|
1511
|
|
|
1512 /**
|
|
|
1513 * Add inline javascript code
|
|
|
1514 *
|
|
|
1515 * @param string $script JS code snippet
|
|
|
1516 * @param string $position Target position [head|head_top|foot]
|
|
|
1517 */
|
|
|
1518 public function add_script($script, $position='head')
|
|
|
1519 {
|
|
|
1520 if (!isset($this->scripts[$position])) {
|
|
|
1521 $this->scripts[$position] = "\n" . rtrim($script);
|
|
|
1522 }
|
|
|
1523 else {
|
|
|
1524 $this->scripts[$position] .= "\n" . rtrim($script);
|
|
|
1525 }
|
|
|
1526 }
|
|
|
1527
|
|
|
1528 /**
|
|
|
1529 * Link an external css file
|
|
|
1530 *
|
|
|
1531 * @param string $file File URL
|
|
|
1532 */
|
|
|
1533 public function include_css($file)
|
|
|
1534 {
|
|
|
1535 $this->css_files[] = $file;
|
|
|
1536 }
|
|
|
1537
|
|
|
1538 /**
|
|
|
1539 * Add HTML code to the page header
|
|
|
1540 *
|
|
|
1541 * @param string $str HTML code
|
|
|
1542 */
|
|
|
1543 public function add_header($str)
|
|
|
1544 {
|
|
|
1545 $this->header .= "\n" . $str;
|
|
|
1546 }
|
|
|
1547
|
|
|
1548 /**
|
|
|
1549 * Add HTML code to the page footer
|
|
|
1550 * To be added right befor </body>
|
|
|
1551 *
|
|
|
1552 * @param string $str HTML code
|
|
|
1553 */
|
|
|
1554 public function add_footer($str)
|
|
|
1555 {
|
|
|
1556 $this->footer .= "\n" . $str;
|
|
|
1557 }
|
|
|
1558
|
|
|
1559 /**
|
|
|
1560 * Process template and write to stdOut
|
|
|
1561 *
|
|
|
1562 * @param string $templ HTML template
|
|
|
1563 * @param string $base_path Base for absolute paths
|
|
|
1564 */
|
|
|
1565 protected function _write($templ = '', $base_path = '')
|
|
|
1566 {
|
|
|
1567 $output = trim($templ);
|
|
|
1568
|
|
|
1569 if (empty($output)) {
|
|
|
1570 $output = html::doctype('html5') . "\n" . $this->default_template;
|
|
|
1571 $is_empty = true;
|
|
|
1572 }
|
|
|
1573
|
|
|
1574 // set default page title
|
|
|
1575 if (empty($this->pagetitle)) {
|
|
|
1576 $this->pagetitle = 'Roundcube Mail';
|
|
|
1577 }
|
|
|
1578
|
|
|
1579 // declare page language
|
|
|
1580 if (!empty($_SESSION['language'])) {
|
|
|
1581 $lang = substr($_SESSION['language'], 0, 2);
|
|
|
1582 $output = preg_replace('/<html/', '<html lang="' . html::quote($lang) . '"', $output, 1);
|
|
|
1583 if (!headers_sent()) {
|
|
|
1584 header('Content-Language: ' . $lang);
|
|
|
1585 }
|
|
|
1586 }
|
|
|
1587
|
|
|
1588 // replace specialchars in content
|
|
|
1589 $page_title = html::quote($this->pagetitle);
|
|
|
1590 $page_header = '';
|
|
|
1591 $page_footer = '';
|
|
|
1592
|
|
|
1593 // include meta tag with charset
|
|
|
1594 if (!empty($this->charset)) {
|
|
|
1595 if (!headers_sent()) {
|
|
|
1596 header('Content-Type: text/html; charset=' . $this->charset);
|
|
|
1597 }
|
|
|
1598 $page_header = '<meta http-equiv="content-type"';
|
|
|
1599 $page_header.= ' content="text/html; charset=';
|
|
|
1600 $page_header.= $this->charset . '" />'."\n";
|
|
|
1601 }
|
|
|
1602
|
|
|
1603 // definition of the code to be placed in the document header and footer
|
|
|
1604 if (is_array($this->script_files['head'])) {
|
|
|
1605 foreach ($this->script_files['head'] as $file) {
|
|
|
1606 $page_header .= html::script($file);
|
|
|
1607 }
|
|
|
1608 }
|
|
|
1609
|
|
|
1610 $head_script = $this->scripts['head_top'] . $this->scripts['head'];
|
|
|
1611 if (!empty($head_script)) {
|
|
|
1612 $page_header .= html::script(array(), $head_script);
|
|
|
1613 }
|
|
|
1614
|
|
|
1615 if (!empty($this->header)) {
|
|
|
1616 $page_header .= $this->header;
|
|
|
1617 }
|
|
|
1618
|
|
|
1619 // put docready commands into page footer
|
|
|
1620 if (!empty($this->scripts['docready'])) {
|
|
|
1621 $this->add_script('$(document).ready(function(){ ' . $this->scripts['docready'] . "\n});", 'foot');
|
|
|
1622 }
|
|
|
1623
|
|
|
1624 if (is_array($this->script_files['foot'])) {
|
|
|
1625 foreach ($this->script_files['foot'] as $file) {
|
|
|
1626 $page_footer .= html::script($file);
|
|
|
1627 }
|
|
|
1628 }
|
|
|
1629
|
|
|
1630 if (!empty($this->footer)) {
|
|
|
1631 $page_footer .= $this->footer . "\n";
|
|
|
1632 }
|
|
|
1633
|
|
|
1634 if (!empty($this->scripts['foot'])) {
|
|
|
1635 $page_footer .= html::script(array(), $this->scripts['foot']);
|
|
|
1636 }
|
|
|
1637
|
|
|
1638 // find page header
|
|
|
1639 if ($hpos = stripos($output, '</head>')) {
|
|
|
1640 $page_header .= "\n";
|
|
|
1641 }
|
|
|
1642 else {
|
|
|
1643 if (!is_numeric($hpos)) {
|
|
|
1644 $hpos = stripos($output, '<body');
|
|
|
1645 }
|
|
|
1646 if (!is_numeric($hpos) && ($hpos = stripos($output, '<html'))) {
|
|
|
1647 while ($output[$hpos] != '>') {
|
|
|
1648 $hpos++;
|
|
|
1649 }
|
|
|
1650 $hpos++;
|
|
|
1651 }
|
|
|
1652 $page_header = "<head>\n<title>$page_title</title>\n$page_header\n</head>\n";
|
|
|
1653 }
|
|
|
1654
|
|
|
1655 // add page hader
|
|
|
1656 if ($hpos) {
|
|
|
1657 $output = substr_replace($output, $page_header, $hpos, 0);
|
|
|
1658 }
|
|
|
1659 else {
|
|
|
1660 $output = $page_header . $output;
|
|
|
1661 }
|
|
|
1662
|
|
|
1663 // add page footer
|
|
|
1664 if (($fpos = strripos($output, '</body>')) || ($fpos = strripos($output, '</html>'))) {
|
|
|
1665 $output = substr_replace($output, $page_footer."\n", $fpos, 0);
|
|
|
1666 }
|
|
|
1667 else {
|
|
|
1668 $output .= "\n".$page_footer;
|
|
|
1669 }
|
|
|
1670
|
|
|
1671 // add css files in head, before scripts, for speed up with parallel downloads
|
|
|
1672 if (!empty($this->css_files) && !$is_empty
|
|
|
1673 && (($pos = stripos($output, '<script ')) || ($pos = stripos($output, '</head>')))
|
|
|
1674 ) {
|
|
|
1675 $css = '';
|
|
|
1676 foreach ($this->css_files as $file) {
|
|
|
1677 $css .= html::tag('link', array('rel' => 'stylesheet',
|
|
|
1678 'type' => 'text/css', 'href' => $file, 'nl' => true));
|
|
|
1679 }
|
|
|
1680 $output = substr_replace($output, $css, $pos, 0);
|
|
|
1681 }
|
|
|
1682
|
|
|
1683 $output = $this->parse_with_globals($this->fix_paths($output));
|
|
|
1684
|
|
|
1685 if ($this->assets_path) {
|
|
|
1686 $output = $this->fix_assets_paths($output);
|
|
|
1687 }
|
|
|
1688
|
|
|
1689 $output = $this->postrender($output);
|
|
|
1690
|
|
|
1691 // trigger hook with final HTML content to be sent
|
|
|
1692 $hook = $this->app->plugins->exec_hook("send_page", array('content' => $output));
|
|
|
1693 if (!$hook['abort']) {
|
|
|
1694 if ($this->charset != RCUBE_CHARSET) {
|
|
|
1695 echo rcube_charset::convert($hook['content'], RCUBE_CHARSET, $this->charset);
|
|
|
1696 }
|
|
|
1697 else {
|
|
|
1698 echo $hook['content'];
|
|
|
1699 }
|
|
|
1700 }
|
|
|
1701 }
|
|
|
1702
|
|
|
1703 /**
|
|
|
1704 * Returns iframe object, registers some related env variables
|
|
|
1705 *
|
|
|
1706 * @param array $attrib HTML attributes
|
|
|
1707 * @param boolean $is_contentframe Register this iframe as the 'contentframe' gui object
|
|
|
1708 *
|
|
|
1709 * @return string IFRAME element
|
|
|
1710 */
|
|
|
1711 public function frame($attrib, $is_contentframe = false)
|
|
|
1712 {
|
|
|
1713 static $idcount = 0;
|
|
|
1714
|
|
|
1715 if (!$attrib['id']) {
|
|
|
1716 $attrib['id'] = 'rcmframe' . ++$idcount;
|
|
|
1717 }
|
|
|
1718
|
|
|
1719 $attrib['name'] = $attrib['id'];
|
|
|
1720 $attrib['src'] = $attrib['src'] ? $this->abs_url($attrib['src'], true) : 'program/resources/blank.gif';
|
|
|
1721
|
|
|
1722 // register as 'contentframe' object
|
|
|
1723 if ($is_contentframe || $attrib['contentframe']) {
|
|
|
1724 $this->set_env('contentframe', $attrib['contentframe'] ? $attrib['contentframe'] : $attrib['name']);
|
|
|
1725 $this->set_env('blankpage', $this->asset_url($attrib['src']));
|
|
|
1726 }
|
|
|
1727
|
|
|
1728 return html::iframe($attrib);
|
|
|
1729 }
|
|
|
1730
|
|
|
1731
|
|
|
1732 /* ************* common functions delivering gui objects ************** */
|
|
|
1733
|
|
|
1734 /**
|
|
|
1735 * Create a form tag with the necessary hidden fields
|
|
|
1736 *
|
|
|
1737 * @param array $attrib Named tag parameters
|
|
|
1738 * @param string $content HTML content of the form
|
|
|
1739 *
|
|
|
1740 * @return string HTML code for the form
|
|
|
1741 */
|
|
|
1742 public function form_tag($attrib, $content = null)
|
|
|
1743 {
|
|
|
1744 if ($this->env['extwin']) {
|
|
|
1745 $hiddenfield = new html_hiddenfield(array('name' => '_extwin', 'value' => '1'));
|
|
|
1746 $hidden = $hiddenfield->show();
|
|
|
1747 }
|
|
|
1748 else if ($this->framed || $this->env['framed']) {
|
|
|
1749 $hiddenfield = new html_hiddenfield(array('name' => '_framed', 'value' => '1'));
|
|
|
1750 $hidden = $hiddenfield->show();
|
|
|
1751 }
|
|
|
1752
|
|
|
1753 if (!$content) {
|
|
|
1754 $attrib['noclose'] = true;
|
|
|
1755 }
|
|
|
1756
|
|
|
1757 return html::tag('form',
|
|
|
1758 $attrib + array('action' => $this->app->comm_path, 'method' => "get"),
|
|
|
1759 $hidden . $content,
|
|
|
1760 array('id','class','style','name','method','action','enctype','onsubmit')
|
|
|
1761 );
|
|
|
1762 }
|
|
|
1763
|
|
|
1764 /**
|
|
|
1765 * Build a form tag with a unique request token
|
|
|
1766 *
|
|
|
1767 * @param array $attrib Named tag parameters including 'action' and 'task' values
|
|
|
1768 * which will be put into hidden fields
|
|
|
1769 * @param string $content Form content
|
|
|
1770 *
|
|
|
1771 * @return string HTML code for the form
|
|
|
1772 */
|
|
|
1773 public function request_form($attrib, $content = '')
|
|
|
1774 {
|
|
|
1775 $hidden = new html_hiddenfield();
|
|
|
1776 if ($attrib['task']) {
|
|
|
1777 $hidden->add(array('name' => '_task', 'value' => $attrib['task']));
|
|
|
1778 }
|
|
|
1779 if ($attrib['action']) {
|
|
|
1780 $hidden->add(array('name' => '_action', 'value' => $attrib['action']));
|
|
|
1781 }
|
|
|
1782
|
|
|
1783 // we already have a <form> tag
|
|
|
1784 if ($attrib['form']) {
|
|
|
1785 if ($this->framed || $this->env['framed']) {
|
|
|
1786 $hidden->add(array('name' => '_framed', 'value' => '1'));
|
|
|
1787 }
|
|
|
1788
|
|
|
1789 return $hidden->show() . $content;
|
|
|
1790 }
|
|
|
1791
|
|
|
1792 unset($attrib['task'], $attrib['request']);
|
|
|
1793 $attrib['action'] = './';
|
|
|
1794
|
|
|
1795 return $this->form_tag($attrib, $hidden->show() . $content);
|
|
|
1796 }
|
|
|
1797
|
|
|
1798 /**
|
|
|
1799 * GUI object 'username'
|
|
|
1800 * Showing IMAP username of the current session
|
|
|
1801 *
|
|
|
1802 * @param array $attrib Named tag parameters (currently not used)
|
|
|
1803 *
|
|
|
1804 * @return string HTML code for the gui object
|
|
|
1805 */
|
|
|
1806 public function current_username($attrib)
|
|
|
1807 {
|
|
|
1808 static $username;
|
|
|
1809
|
|
|
1810 // alread fetched
|
|
|
1811 if (!empty($username)) {
|
|
|
1812 return $username;
|
|
|
1813 }
|
|
|
1814
|
|
|
1815 // Current username is an e-mail address
|
|
|
1816 if (strpos($_SESSION['username'], '@')) {
|
|
|
1817 $username = $_SESSION['username'];
|
|
|
1818 }
|
|
|
1819 // get e-mail address from default identity
|
|
|
1820 else if ($sql_arr = $this->app->user->get_identity()) {
|
|
|
1821 $username = $sql_arr['email'];
|
|
|
1822 }
|
|
|
1823 else {
|
|
|
1824 $username = $this->app->user->get_username();
|
|
|
1825 }
|
|
|
1826
|
|
|
1827 return rcube_utils::idn_to_utf8($username);
|
|
|
1828 }
|
|
|
1829
|
|
|
1830 /**
|
|
|
1831 * GUI object 'loginform'
|
|
|
1832 * Returns code for the webmail login form
|
|
|
1833 *
|
|
|
1834 * @param array $attrib Named parameters
|
|
|
1835 *
|
|
|
1836 * @return string HTML code for the gui object
|
|
|
1837 */
|
|
|
1838 protected function login_form($attrib)
|
|
|
1839 {
|
|
|
1840 $default_host = $this->config->get('default_host');
|
|
|
1841 $autocomplete = (int) $this->config->get('login_autocomplete');
|
|
|
1842
|
|
|
1843 $_SESSION['temp'] = true;
|
|
|
1844
|
|
|
1845 // save original url
|
|
|
1846 $url = rcube_utils::get_input_value('_url', rcube_utils::INPUT_POST);
|
|
|
1847 if (empty($url) && !preg_match('/_(task|action)=logout/', $_SERVER['QUERY_STRING']))
|
|
|
1848 $url = $_SERVER['QUERY_STRING'];
|
|
|
1849
|
|
|
1850 // Disable autocapitalization on iPad/iPhone (#1488609)
|
|
|
1851 $attrib['autocapitalize'] = 'off';
|
|
|
1852
|
|
|
1853 $form_name = !empty($attrib['form']) ? $attrib['form'] : 'form';
|
|
|
1854
|
|
|
1855 // set atocomplete attribute
|
|
|
1856 $user_attrib = $autocomplete > 0 ? array() : array('autocomplete' => 'off');
|
|
|
1857 $host_attrib = $autocomplete > 0 ? array() : array('autocomplete' => 'off');
|
|
|
1858 $pass_attrib = $autocomplete > 1 ? array() : array('autocomplete' => 'off');
|
|
|
1859
|
|
|
1860 $input_task = new html_hiddenfield(array('name' => '_task', 'value' => 'login'));
|
|
|
1861 $input_action = new html_hiddenfield(array('name' => '_action', 'value' => 'login'));
|
|
|
1862 $input_tzone = new html_hiddenfield(array('name' => '_timezone', 'id' => 'rcmlogintz', 'value' => '_default_'));
|
|
|
1863 $input_url = new html_hiddenfield(array('name' => '_url', 'id' => 'rcmloginurl', 'value' => $url));
|
|
|
1864 $input_user = new html_inputfield(array('name' => '_user', 'id' => 'rcmloginuser', 'required' => 'required')
|
|
|
1865 + $attrib + $user_attrib);
|
|
|
1866 $input_pass = new html_passwordfield(array('name' => '_pass', 'id' => 'rcmloginpwd', 'required' => 'required')
|
|
|
1867 + $attrib + $pass_attrib);
|
|
|
1868 $input_host = null;
|
|
|
1869
|
|
|
1870 if (is_array($default_host) && count($default_host) > 1) {
|
|
|
1871 $input_host = new html_select(array('name' => '_host', 'id' => 'rcmloginhost'));
|
|
|
1872
|
|
|
1873 foreach ($default_host as $key => $value) {
|
|
|
1874 if (!is_array($value)) {
|
|
|
1875 $input_host->add($value, (is_numeric($key) ? $value : $key));
|
|
|
1876 }
|
|
|
1877 else {
|
|
|
1878 $input_host = null;
|
|
|
1879 break;
|
|
|
1880 }
|
|
|
1881 }
|
|
|
1882 }
|
|
|
1883 else if (is_array($default_host) && ($host = key($default_host)) !== null) {
|
|
|
1884 $hide_host = true;
|
|
|
1885 $input_host = new html_hiddenfield(array(
|
|
|
1886 'name' => '_host', 'id' => 'rcmloginhost', 'value' => is_numeric($host) ? $default_host[$host] : $host) + $attrib);
|
|
|
1887 }
|
|
|
1888 else if (empty($default_host)) {
|
|
|
1889 $input_host = new html_inputfield(array('name' => '_host', 'id' => 'rcmloginhost')
|
|
|
1890 + $attrib + $host_attrib);
|
|
|
1891 }
|
|
|
1892
|
|
|
1893 $this->add_gui_object('loginform', $form_name);
|
|
|
1894
|
|
|
1895 // create HTML table with two cols
|
|
|
1896 $table = new html_table(array('cols' => 2));
|
|
|
1897
|
|
|
1898 $table->add('title', html::label('rcmloginuser', html::quote($this->app->gettext('username'))));
|
|
|
1899 $table->add('input', $input_user->show(rcube_utils::get_input_value('_user', rcube_utils::INPUT_GPC)));
|
|
|
1900
|
|
|
1901 $table->add('title', html::label('rcmloginpwd', html::quote($this->app->gettext('password'))));
|
|
|
1902 $table->add('input', $input_pass->show());
|
|
|
1903
|
|
|
1904 // add host selection row
|
|
|
1905 if (is_object($input_host) && !$hide_host) {
|
|
|
1906 $table->add('title', html::label('rcmloginhost', html::quote($this->app->gettext('server'))));
|
|
|
1907 $table->add('input', $input_host->show(rcube_utils::get_input_value('_host', rcube_utils::INPUT_GPC)));
|
|
|
1908 }
|
|
|
1909
|
|
|
1910 $out = $input_task->show();
|
|
|
1911 $out .= $input_action->show();
|
|
|
1912 $out .= $input_tzone->show();
|
|
|
1913 $out .= $input_url->show();
|
|
|
1914 $out .= $table->show();
|
|
|
1915
|
|
|
1916 if ($hide_host) {
|
|
|
1917 $out .= $input_host->show();
|
|
|
1918 }
|
|
|
1919
|
|
|
1920 if (rcube_utils::get_boolean($attrib['submit'])) {
|
|
|
1921 $submit = new html_inputfield(array('type' => 'submit', 'id' => 'rcmloginsubmit',
|
|
|
1922 'class' => 'button mainaction', 'value' => $this->app->gettext('login')));
|
|
|
1923 $out .= html::p('formbuttons', $submit->show());
|
|
|
1924 }
|
|
|
1925
|
|
|
1926 // surround html output with a form tag
|
|
|
1927 if (empty($attrib['form'])) {
|
|
|
1928 $out = $this->form_tag(array('name' => $form_name, 'method' => 'post'), $out);
|
|
|
1929 }
|
|
|
1930
|
|
|
1931 // include script for timezone detection
|
|
|
1932 $this->include_script('jstz.min.js');
|
|
|
1933
|
|
|
1934 return $out;
|
|
|
1935 }
|
|
|
1936
|
|
|
1937 /**
|
|
|
1938 * GUI object 'preloader'
|
|
|
1939 * Loads javascript code for images preloading
|
|
|
1940 *
|
|
|
1941 * @param array $attrib Named parameters
|
|
|
1942 * @return void
|
|
|
1943 */
|
|
|
1944 protected function preloader($attrib)
|
|
|
1945 {
|
|
|
1946 $images = preg_split('/[\s\t\n,]+/', $attrib['images'], -1, PREG_SPLIT_NO_EMPTY);
|
|
|
1947 $images = array_map(array($this, 'abs_url'), $images);
|
|
|
1948 $images = array_map(array($this, 'asset_url'), $images);
|
|
|
1949
|
|
|
1950 if (empty($images) || $_REQUEST['_task'] == 'logout') {
|
|
|
1951 return;
|
|
|
1952 }
|
|
|
1953
|
|
|
1954 $this->add_script('var images = ' . self::json_serialize($images, $this->devel_mode) .';
|
|
|
1955 for (var i=0; i<images.length; i++) {
|
|
|
1956 img = new Image();
|
|
|
1957 img.src = images[i];
|
|
|
1958 }', 'docready');
|
|
|
1959 }
|
|
|
1960
|
|
|
1961 /**
|
|
|
1962 * GUI object 'searchform'
|
|
|
1963 * Returns code for search function
|
|
|
1964 *
|
|
|
1965 * @param array $attrib Named parameters
|
|
|
1966 *
|
|
|
1967 * @return string HTML code for the gui object
|
|
|
1968 */
|
|
|
1969 protected function search_form($attrib)
|
|
|
1970 {
|
|
|
1971 // add some labels to client
|
|
|
1972 $this->add_label('searching');
|
|
|
1973
|
|
|
1974 $attrib['name'] = '_q';
|
|
|
1975
|
|
|
1976 if (empty($attrib['id'])) {
|
|
|
1977 $attrib['id'] = 'rcmqsearchbox';
|
|
|
1978 }
|
|
|
1979 if ($attrib['type'] == 'search' && !$this->browser->khtml) {
|
|
|
1980 unset($attrib['type'], $attrib['results']);
|
|
|
1981 }
|
|
|
1982
|
|
|
1983 $input_q = new html_inputfield($attrib);
|
|
|
1984 $out = $input_q->show();
|
|
|
1985
|
|
|
1986 $this->add_gui_object('qsearchbox', $attrib['id']);
|
|
|
1987
|
|
|
1988 // add form tag around text field
|
|
|
1989 if (empty($attrib['form'])) {
|
|
|
1990 $out = $this->form_tag(array(
|
|
|
1991 'name' => "rcmqsearchform",
|
|
|
1992 'onsubmit' => self::JS_OBJECT_NAME . ".command('search'); return false",
|
|
|
1993 'style' => "display:inline"
|
|
|
1994 ), $out);
|
|
|
1995 }
|
|
|
1996
|
|
|
1997 return $out;
|
|
|
1998 }
|
|
|
1999
|
|
|
2000 /**
|
|
|
2001 * Builder for GUI object 'message'
|
|
|
2002 *
|
|
|
2003 * @param array Named tag parameters
|
|
|
2004 * @return string HTML code for the gui object
|
|
|
2005 */
|
|
|
2006 protected function message_container($attrib)
|
|
|
2007 {
|
|
|
2008 if (isset($attrib['id']) === false) {
|
|
|
2009 $attrib['id'] = 'rcmMessageContainer';
|
|
|
2010 }
|
|
|
2011
|
|
|
2012 $this->add_gui_object('message', $attrib['id']);
|
|
|
2013
|
|
|
2014 return html::div($attrib, '');
|
|
|
2015 }
|
|
|
2016
|
|
|
2017 /**
|
|
|
2018 * GUI object 'charsetselector'
|
|
|
2019 *
|
|
|
2020 * @param array $attrib Named parameters for the select tag
|
|
|
2021 *
|
|
|
2022 * @return string HTML code for the gui object
|
|
|
2023 */
|
|
|
2024 public function charset_selector($attrib)
|
|
|
2025 {
|
|
|
2026 // pass the following attributes to the form class
|
|
|
2027 $field_attrib = array('name' => '_charset');
|
|
|
2028 foreach ($attrib as $attr => $value) {
|
|
|
2029 if (in_array($attr, array('id', 'name', 'class', 'style', 'size', 'tabindex'))) {
|
|
|
2030 $field_attrib[$attr] = $value;
|
|
|
2031 }
|
|
|
2032 }
|
|
|
2033
|
|
|
2034 $charsets = array(
|
|
|
2035 'UTF-8' => 'UTF-8 ('.$this->app->gettext('unicode').')',
|
|
|
2036 'US-ASCII' => 'ASCII ('.$this->app->gettext('english').')',
|
|
|
2037 'ISO-8859-1' => 'ISO-8859-1 ('.$this->app->gettext('westerneuropean').')',
|
|
|
2038 'ISO-8859-2' => 'ISO-8859-2 ('.$this->app->gettext('easterneuropean').')',
|
|
|
2039 'ISO-8859-4' => 'ISO-8859-4 ('.$this->app->gettext('baltic').')',
|
|
|
2040 'ISO-8859-5' => 'ISO-8859-5 ('.$this->app->gettext('cyrillic').')',
|
|
|
2041 'ISO-8859-6' => 'ISO-8859-6 ('.$this->app->gettext('arabic').')',
|
|
|
2042 'ISO-8859-7' => 'ISO-8859-7 ('.$this->app->gettext('greek').')',
|
|
|
2043 'ISO-8859-8' => 'ISO-8859-8 ('.$this->app->gettext('hebrew').')',
|
|
|
2044 'ISO-8859-9' => 'ISO-8859-9 ('.$this->app->gettext('turkish').')',
|
|
|
2045 'ISO-8859-10' => 'ISO-8859-10 ('.$this->app->gettext('nordic').')',
|
|
|
2046 'ISO-8859-11' => 'ISO-8859-11 ('.$this->app->gettext('thai').')',
|
|
|
2047 'ISO-8859-13' => 'ISO-8859-13 ('.$this->app->gettext('baltic').')',
|
|
|
2048 'ISO-8859-14' => 'ISO-8859-14 ('.$this->app->gettext('celtic').')',
|
|
|
2049 'ISO-8859-15' => 'ISO-8859-15 ('.$this->app->gettext('westerneuropean').')',
|
|
|
2050 'ISO-8859-16' => 'ISO-8859-16 ('.$this->app->gettext('southeasterneuropean').')',
|
|
|
2051 'WINDOWS-1250' => 'Windows-1250 ('.$this->app->gettext('easterneuropean').')',
|
|
|
2052 'WINDOWS-1251' => 'Windows-1251 ('.$this->app->gettext('cyrillic').')',
|
|
|
2053 'WINDOWS-1252' => 'Windows-1252 ('.$this->app->gettext('westerneuropean').')',
|
|
|
2054 'WINDOWS-1253' => 'Windows-1253 ('.$this->app->gettext('greek').')',
|
|
|
2055 'WINDOWS-1254' => 'Windows-1254 ('.$this->app->gettext('turkish').')',
|
|
|
2056 'WINDOWS-1255' => 'Windows-1255 ('.$this->app->gettext('hebrew').')',
|
|
|
2057 'WINDOWS-1256' => 'Windows-1256 ('.$this->app->gettext('arabic').')',
|
|
|
2058 'WINDOWS-1257' => 'Windows-1257 ('.$this->app->gettext('baltic').')',
|
|
|
2059 'WINDOWS-1258' => 'Windows-1258 ('.$this->app->gettext('vietnamese').')',
|
|
|
2060 'ISO-2022-JP' => 'ISO-2022-JP ('.$this->app->gettext('japanese').')',
|
|
|
2061 'ISO-2022-KR' => 'ISO-2022-KR ('.$this->app->gettext('korean').')',
|
|
|
2062 'ISO-2022-CN' => 'ISO-2022-CN ('.$this->app->gettext('chinese').')',
|
|
|
2063 'EUC-JP' => 'EUC-JP ('.$this->app->gettext('japanese').')',
|
|
|
2064 'EUC-KR' => 'EUC-KR ('.$this->app->gettext('korean').')',
|
|
|
2065 'EUC-CN' => 'EUC-CN ('.$this->app->gettext('chinese').')',
|
|
|
2066 'BIG5' => 'BIG5 ('.$this->app->gettext('chinese').')',
|
|
|
2067 'GB2312' => 'GB2312 ('.$this->app->gettext('chinese').')',
|
|
|
2068 );
|
|
|
2069
|
|
|
2070 if ($post = rcube_utils::get_input_value('_charset', rcube_utils::INPUT_POST)) {
|
|
|
2071 $set = $post;
|
|
|
2072 }
|
|
|
2073 else if (!empty($attrib['selected'])) {
|
|
|
2074 $set = $attrib['selected'];
|
|
|
2075 }
|
|
|
2076 else {
|
|
|
2077 $set = $this->get_charset();
|
|
|
2078 }
|
|
|
2079
|
|
|
2080 $set = strtoupper($set);
|
|
|
2081 if (!isset($charsets[$set]) && preg_match('/^[A-Z0-9-]+$/', $set)) {
|
|
|
2082 $charsets[$set] = $set;
|
|
|
2083 }
|
|
|
2084
|
|
|
2085 $select = new html_select($field_attrib);
|
|
|
2086 $select->add(array_values($charsets), array_keys($charsets));
|
|
|
2087
|
|
|
2088 return $select->show($set);
|
|
|
2089 }
|
|
|
2090
|
|
|
2091 /**
|
|
|
2092 * Include content from config/about.<LANG>.html if available
|
|
|
2093 */
|
|
|
2094 protected function about_content($attrib)
|
|
|
2095 {
|
|
|
2096 $content = '';
|
|
|
2097 $filenames = array(
|
|
|
2098 'about.' . $_SESSION['language'] . '.html',
|
|
|
2099 'about.' . substr($_SESSION['language'], 0, 2) . '.html',
|
|
|
2100 'about.html',
|
|
|
2101 );
|
|
|
2102 foreach ($filenames as $file) {
|
|
|
2103 $fn = RCUBE_CONFIG_DIR . $file;
|
|
|
2104 if (is_readable($fn)) {
|
|
|
2105 $content = file_get_contents($fn);
|
|
|
2106 $content = $this->parse_conditions($content);
|
|
|
2107 $content = $this->parse_xml($content);
|
|
|
2108 break;
|
|
|
2109 }
|
|
|
2110 }
|
|
|
2111
|
|
|
2112 return $content;
|
|
|
2113 }
|
|
|
2114 }
|
