PageRenderTime 55ms CodeModel.GetById 15ms RepoModel.GetById 0ms app.codeStats 1ms

/lib/weblib.php

https://bitbucket.org/ceu/moodle_demo
PHP | 7269 lines | 5119 code | 743 blank | 1407 comment | 932 complexity | bbefc14d9291c58240eb05d7ec3c25a9 MD5 | raw file
Possible License(s): BSD-3-Clause, LGPL-2.0, LGPL-2.1

Large files files are truncated, but you can click here to view the full file

    

  1. <?php // $Id$

    2. 

  2. 

    3. 

  3. ///////////////////////////////////////////////////////////////////////////

    4. 

  4. //                                                                       //

    5. 

  5. // NOTICE OF COPYRIGHT                                                   //

    6. 

  6. //                                                                       //

    7. 

  7. // Moodle - Modular Object-Oriented Dynamic Learning Environment         //

    8. 

  8. //          http://moodle.com                                            //

    9. 

  9. //                                                                       //

    10. 

  10. // Copyright (C) 1999 onwards Martin Dougiamas  http://dougiamas.com     //

    11. 

  11. //                                                                       //

    12. 

  12. // This program is free software; you can redistribute it and/or modify  //

    13. 

  13. // it under the terms of the GNU General Public License as published by  //

    14. 

  14. // the Free Software Foundation; either version 2 of the License, or     //

    15. 

  15. // (at your option) any later version.                                   //

    16. 

  16. //                                                                       //

    17. 

  17. // This program is distributed in the hope that it will be useful,       //

    18. 

  18. // but WITHOUT ANY WARRANTY; without even the implied warranty of        //

    19. 

  19. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         //

    20. 

  20. // GNU General Public License for more details:                          //

    21. 

  21. //                                                                       //

    22. 

  22. //          http://www.gnu.org/copyleft/gpl.html                         //

    23. 

  23. //                                                                       //

    24. 

  24. ///////////////////////////////////////////////////////////////////////////

    25. 

  25. 

    26. 

  26. /**

    27. 

  27.  * Library of functions for web output

    28. 

  28.  *

    29. 

  29.  * Library of all general-purpose Moodle PHP functions and constants

    30. 

  30.  * that produce HTML output

    31. 

  31.  *

    32. 

  32.  * Other main libraries:

    33. 

  33.  * - datalib.php - functions that access the database.

    34. 

  34.  * - moodlelib.php - general-purpose Moodle functions.

    35. 

  35.  * @author Martin Dougiamas

    36. 

  36.  * @version  $Id$

    37. 

  37.  * @license http://www.gnu.org/copyleft/gpl.html GNU Public License

    38. 

  38.  * @package moodlecore

    39. 

  39.  */

    40. 

  40. 

    41. 

  41. /// We are going to uses filterlib functions here

    42. 

  42. require_once("$CFG->libdir/filterlib.php");

    43. 

  43. 

    44. 

  44. require_once("$CFG->libdir/ajax/ajaxlib.php");

    45. 

  45. 

    46. 

  46. /// Constants

    47. 

  47. 

    48. 

  48. /// Define text formatting types ... eventually we can add Wiki, BBcode etc

    49. 

  49. 

    50. 

  50. /**

    51. 

  51.  * Does all sorts of transformations and filtering

    52. 

  52.  */

    53. 

  53. define('FORMAT_MOODLE',   '0');   // Does all sorts of transformations and filtering

    54. 

  54. 

    55. 

  55. /**

    56. 

  56.  * Plain HTML (with some tags stripped)

    57. 

  57.  */

    58. 

  58. define('FORMAT_HTML',     '1');   // Plain HTML (with some tags stripped)

    59. 

  59. 

    60. 

  60. /**

    61. 

  61.  * Plain text (even tags are printed in full)

    62. 

  62.  */

    63. 

  63. define('FORMAT_PLAIN',    '2');   // Plain text (even tags are printed in full)

    64. 

  64. 

    65. 

  65. /**

    66. 

  66.  * Wiki-formatted text

    67. 

  67.  * Deprecated: left here just to note that '3' is not used (at the moment)

    68. 

  68.  * and to catch any latent wiki-like text (which generates an error)

    69. 

  69.  */

    70. 

  70. define('FORMAT_WIKI',     '3');   // Wiki-formatted text

    71. 

  71. 

    72. 

  72. /**

    73. 

  73.  * Markdown-formatted text http://daringfireball.net/projects/markdown/

    74. 

  74.  */

    75. 

  75. define('FORMAT_MARKDOWN', '4');   // Markdown-formatted text http://daringfireball.net/projects/markdown/

    76. 

  76. 

    77. 

  77. /**

    78. 

  78.  * TRUSTTEXT marker - if present in text, text cleaning should be bypassed

    79. 

  79.  */

    80. 

  80. define('TRUSTTEXT', '#####TRUSTTEXT#####');

    81. 

  81. 

    82. 

  82. 

    83. 

  83. /**

    84. 

  84.  * Javascript related defines

    85. 

  85.  */

    86. 

  86. define('REQUIREJS_BEFOREHEADER', 0);

    87. 

  87. define('REQUIREJS_INHEADER',     1);

    88. 

  88. define('REQUIREJS_AFTERHEADER',  2);

    89. 

  89. 

    90. 

  90. /**

    91. 

  91.  * Allowed tags - string of html tags that can be tested against for safe html tags

    92. 

  92.  * @global string $ALLOWED_TAGS

    93. 

  93.  */

    94. 

  94. global $ALLOWED_TAGS;

    95. 

  95. $ALLOWED_TAGS =

    96. 

  96. '<p><br><b><i><u><font><table><tbody><thead><tfoot><span><div><tr><td><th><ol><ul><dl><li><dt><dd><h1><h2><h3><h4><h5><h6><hr><img><a><strong><emphasis><em><sup><sub><address><cite><blockquote><pre><strike><param><acronym><nolink><lang><tex><algebra><math><mi><mn><mo><mtext><mspace><ms><mrow><mfrac><msqrt><mroot><mstyle><merror><mpadded><mphantom><mfenced><msub><msup><msubsup><munder><mover><munderover><mmultiscripts><mtable><mtr><mtd><maligngroup><malignmark><maction><cn><ci><apply><reln><fn><interval><inverse><sep><condition><declare><lambda><compose><ident><quotient><exp><factorial><divide><max><min><minus><plus><power><rem><times><root><gcd><and><or><xor><not><implies><forall><exists><abs><conjugate><eq><neq><gt><lt><geq><leq><ln><log><int><diff><partialdiff><lowlimit><uplimit><bvar><degree><set><list><union><intersect><in><notin><subset><prsubset><notsubset><notprsubset><setdiff><sum><product><limit><tendsto><mean><sdev><variance><median><mode><moment><vector><matrix><matrixrow><determinant><transpose><selector><annotation><semantics><annotation-xml><tt><code>';

    97. 

  97. 

    98. 

  98. /**

    99. 

  99.  * Allowed protocols - array of protocols that are safe to use in links and so on

    100. 

  100.  * @global string $ALLOWED_PROTOCOLS

    101. 

  101.  */

    102. 

  102. $ALLOWED_PROTOCOLS = array('http', 'https', 'ftp', 'news', 'mailto', 'rtsp', 'teamspeak', 'gopher', 'mms',

    103. 

  103.                            'color', 'callto', 'cursor', 'text-align', 'font-size', 'font-weight', 'font-style', 'font-family',

    104. 

  104.                            'border', 'border-bottom', 'border-left', 'border-top', 'border-right', 'margin', 'margin-bottom', 'margin-left', 'margin-top', 'margin-right',

    105. 

  105.                            'padding', 'padding-bottom', 'padding-left', 'padding-top', 'padding-right', 'vertical-align',

    106. 

  106.                            'background', 'background-color', 'text-decoration');   // CSS as well to get through kses

    107. 

  107. 

    108. 

  108. 

    109. 

  109. /// Functions

    110. 

  110. 

    111. 

  111. /**

    112. 

  112.  * Add quotes to HTML characters

    113. 

  113.  *

    114. 

  114.  * Returns $var with HTML characters (like "<", ">", etc.) properly quoted.

    115. 

  115.  * This function is very similar to {@link p()}

    116. 

  116.  *

    117. 

  117.  * @param string $var the string potentially containing HTML characters

    118. 

  118.  * @param boolean $strip to decide if we want to strip slashes or no. Default to false.

    119. 

  119.  *                true should be used to print data from forms and false for data from DB.

    120. 

  120.  * @return string

    121. 

  121.  */

    122. 

  122. function s($var, $strip=false) {

    123. 

  123. 

    124. 

  124.     if ($var === '0' or $var === false or $var === 0) {

    125. 

  125.         return '0';

    126. 

  126.     }

    127. 

  127. 

    128. 

  128.     if ($strip) {

    129. 

  129.         return preg_replace("/&amp;(#\d+);/i", "&$1;", htmlspecialchars(stripslashes_safe($var)));

    130. 

  130.     } else {

    131. 

  131.         return preg_replace("/&amp;(#\d+);/i", "&$1;", htmlspecialchars($var));

    132. 

  132.     }

    133. 

  133. }

    134. 

  134. 

    135. 

  135. /**

    136. 

  136.  * Add quotes to HTML characters

    137. 

  137.  *

    138. 

  138.  * Prints $var with HTML characters (like "<", ">", etc.) properly quoted.

    139. 

  139.  * This function is very similar to {@link s()}

    140. 

  140.  *

    141. 

  141.  * @param string $var the string potentially containing HTML characters

    142. 

  142.  * @param boolean $strip to decide if we want to strip slashes or no. Default to false.

    143. 

  143.  *                true should be used to print data from forms and false for data from DB.

    144. 

  144.  * @return string

    145. 

  145.  */

    146. 

  146. function p($var, $strip=false) {

    147. 

  147.     echo s($var, $strip);

    148. 

  148. }

    149. 

  149. 

    150. 

  150. /**

    151. 

  151.  * Does proper javascript quoting.

    152. 

  152.  * Do not use addslashes anymore, because it does not work when magic_quotes_sybase is enabled.

    153. 

  153.  *

    154. 

  154.  * @since 1.8 - 22/02/2007

    155. 

  155.  * @param mixed value

    156. 

  156.  * @return mixed quoted result

    157. 

  157.  */

    158. 

  158. function addslashes_js($var) {

    159. 

  159.     if (is_string($var)) {

    160. 

  160.         $var = str_replace('\\', '\\\\', $var);

    161. 

  161.         $var = str_replace(array('\'', '"', "\n", "\r", "\0"), array('\\\'', '\\"', '\\n', '\\r', '\\0'), $var);

    162. 

  162.         $var = str_replace('</', '<\/', $var);   // XHTML compliance

    163. 

  163.     } else if (is_array($var)) {

    164. 

  164.         $var = array_map('addslashes_js', $var);

    165. 

  165.     } else if (is_object($var)) {

    166. 

  166.         $a = get_object_vars($var);

    167. 

  167.         foreach ($a as $key=>$value) {

    168. 

  168.           $a[$key] = addslashes_js($value);

    169. 

  169.         }

    170. 

  170.         $var = (object)$a;

    171. 

  171.     }

    172. 

  172.     return $var;

    173. 

  173. }

    174. 

  174. 

    175. 

  175. /**

    176. 

  176.  * Remove query string from url

    177. 

  177.  *

    178. 

  178.  * Takes in a URL and returns it without the querystring portion

    179. 

  179.  *

    180. 

  180.  * @param string $url the url which may have a query string attached

    181. 

  181.  * @return string

    182. 

  182.  */

    183. 

  183.  function strip_querystring($url) {

    184. 

  184. 

    185. 

  185.     if ($commapos = strpos($url, '?')) {

    186. 

  186.         return substr($url, 0, $commapos);

    187. 

  187.     } else {

    188. 

  188.         return $url;

    189. 

  189.     }

    190. 

  190. }

    191. 

  191. 

    192. 

  192. /**

    193. 

  193.  * Returns the URL of the HTTP_REFERER, less the querystring portion if required

    194. 

  194.  * @param boolean $stripquery if true, also removes the query part of the url.

    195. 

  195.  * @return string

    196. 

  196.  */

    197. 

  197. function get_referer($stripquery=true) {

    198. 

  198.     if (isset($_SERVER['HTTP_REFERER'])) {

    199. 

  199.         if ($stripquery) {

    200. 

  200.             return strip_querystring($_SERVER['HTTP_REFERER']);

    201. 

  201.         } else {

    202. 

  202.             return $_SERVER['HTTP_REFERER'];

    203. 

  203.         }

    204. 

  204.     } else {

    205. 

  205.         return '';

    206. 

  206.     }

    207. 

  207. }

    208. 

  208. 

    209. 

  209. 

    210. 

  210. /**

    211. 

  211.  * Returns the name of the current script, WITH the querystring portion.

    212. 

  212.  * this function is necessary because PHP_SELF and REQUEST_URI and SCRIPT_NAME

    213. 

  213.  * return different things depending on a lot of things like your OS, Web

    214. 

  214.  * server, and the way PHP is compiled (ie. as a CGI, module, ISAPI, etc.)

    215. 

  215.  * <b>NOTE:</b> This function returns false if the global variables needed are not set.

    216. 

  216.  *

    217. 

  217.  * @return string

    218. 

  218.  */

    219. 

  219. function me() {

    220. 

  220.     if (!empty($_SERVER['REQUEST_URI'])) {

    221. 

  221.         $return = $_SERVER['REQUEST_URI'];

    222. 

  222. 

    223. 

  223.     } else if (!empty($_SERVER['PHP_SELF'])) {

    224. 

  224.         if (!empty($_SERVER['QUERY_STRING'])) {

    225. 

  225.             $return = $_SERVER['PHP_SELF'] .'?'. $_SERVER['QUERY_STRING'];

    226. 

  226.         } else {

    227. 

  227.             $return = $_SERVER['PHP_SELF'];

    228. 

  228.         }

    229. 

  229. 

    230. 

  230.     } else if (!empty($_SERVER['SCRIPT_NAME'])) {

    231. 

  231.         if (!empty($_SERVER['QUERY_STRING'])) {

    232. 

  232.             $return = $_SERVER['SCRIPT_NAME'] .'?'. $_SERVER['QUERY_STRING'];

    233. 

  233.         } else {

    234. 

  234.             $return = $_SERVER['SCRIPT_NAME'];

    235. 

  235.         }

    236. 

  236. 

    237. 

  237.     } else if (!empty($_SERVER['URL'])) {     // May help IIS (not well tested)

    238. 

  238.         if (!empty($_SERVER['QUERY_STRING'])) {

    239. 

  239.             $return = $_SERVER['URL'] .'?'. $_SERVER['QUERY_STRING'];

    240. 

  240.         } else {

    241. 

  241.             $return = $_SERVER['URL'];

    242. 

  242.         }

    243. 

  243. 

    244. 

  244.     } else {

    245. 

  245.         notify('Warning: Could not find any of these web server variables: $REQUEST_URI, $PHP_SELF, $SCRIPT_NAME or $URL');

    246. 

  246.         return false;

    247. 

  247.     }

    248. 

  248. 

    249. 

  249.     // sanitize the url a bit more, the encoding style may be different in vars above

    250. 

  250.     $return = str_replace('"', '%22', $return);

    251. 

  251.     $return = str_replace('\'', '%27', $return);

    252. 

  252. 

    253. 

  253.     return $return;

    254. 

  254. }

    255. 

  255. 

    256. 

  256. /**

    257. 

  257.  * Like {@link me()} but returns a full URL

    258. 

  258.  * @see me()

    259. 

  259.  * @return string

    260. 

  260.  */

    261. 

  261. function qualified_me() {

    262. 

  262. 

    263. 

  263.     global $CFG;

    264. 

  264. 

    265. 

  265.     if (!empty($CFG->wwwroot)) {

    266. 

  266.         $url = parse_url($CFG->wwwroot);

    267. 

  267.     }

    268. 

  268. 

    269. 

  269.     if (!empty($url['host'])) {

    270. 

  270.         $hostname = $url['host'];

    271. 

  271.     } else if (!empty($_SERVER['SERVER_NAME'])) {

    272. 

  272.         $hostname = $_SERVER['SERVER_NAME'];

    273. 

  273.     } else if (!empty($_ENV['SERVER_NAME'])) {

    274. 

  274.         $hostname = $_ENV['SERVER_NAME'];

    275. 

  275.     } else if (!empty($_SERVER['HTTP_HOST'])) {

    276. 

  276.         $hostname = $_SERVER['HTTP_HOST'];

    277. 

  277.     } else if (!empty($_ENV['HTTP_HOST'])) {

    278. 

  278.         $hostname = $_ENV['HTTP_HOST'];

    279. 

  279.     } else {

    280. 

  280.         notify('Warning: could not find the name of this server!');

    281. 

  281.         return false;

    282. 

  282.     }

    283. 

  283. 

    284. 

  284.     if (!empty($url['port'])) {

    285. 

  285.         $hostname .= ':'.$url['port'];

    286. 

  286.     } else if (!empty($_SERVER['SERVER_PORT'])) {

    287. 

  287.         if ($_SERVER['SERVER_PORT'] != 80 && $_SERVER['SERVER_PORT'] != 443) {

    288. 

  288.             $hostname .= ':'.$_SERVER['SERVER_PORT'];

    289. 

  289.         }

    290. 

  290.     }

    291. 

  291. 

    292. 

  292.     // TODO, this does not work in the situation described in MDL-11061, but

    293. 

  293.     // I don't know how to fix it. Possibly believe $CFG->wwwroot ahead of what

    294. 

  294.     // the server reports.

    295. 

  295.     if (isset($_SERVER['HTTPS'])) {

    296. 

  296.         $protocol = ($_SERVER['HTTPS'] == 'on') ? 'https://' : 'http://';

    297. 

  297.     } else if (isset($_SERVER['SERVER_PORT'])) { # Apache2 does not export $_SERVER['HTTPS']

    298. 

  298.         $protocol = ($_SERVER['SERVER_PORT'] == '443') ? 'https://' : 'http://';

    299. 

  299.     } else {

    300. 

  300.         $protocol = 'http://';

    301. 

  301.     }

    302. 

  302. 

    303. 

  303.     $url_prefix = $protocol.$hostname;

    304. 

  304.     return $url_prefix . me();

    305. 

  305. }

    306. 

  306. 

    307. 

  307. 

    308. 

  308. /**

    309. 

  309.  * Class for creating and manipulating urls.

    310. 

  310.  *

    311. 

  311.  * See short write up here http://docs.moodle.org/dev/lib/weblib.php_moodle_url

    312. 

  312.  */

    313. 

  313. class moodle_url {

    314. 

  314.     var $scheme = '';// e.g. http

    315. 

  315.     var $host = '';

    316. 

  316.     var $port = '';

    317. 

  317.     var $user = '';

    318. 

  318.     var $pass = '';

    319. 

  319.     var $path = '';

    320. 

  320.     var $fragment = '';

    321. 

  321.     var $params = array(); //associative array of query string params

    322. 

  322. 

    323. 

  323.     /**

    324. 

  324.      * Pass no arguments to create a url that refers to this page. Use empty string to create empty url.

    325. 

  325.      *

    326. 

  326.      * @param string $url url default null means use this page url with no query string

    327. 

  327.      *                      empty string means empty url.

    328. 

  328.      *                      if you pass any other type of url it will be parsed into it's bits, including query string

    329. 

  329.      * @param array $params these params override anything in the query string where params have the same name.

    330. 

  330.      */

    331. 

  331.     function moodle_url($url = null, $params = array()){

    332. 

  332.         global $FULLME;

    333. 

  333.         if ($url !== ''){

    334. 

  334.             if ($url === null){

    335. 

  335.                 $url = strip_querystring($FULLME);

    336. 

  336.             }

    337. 

  337.             $parts = parse_url($url);

    338. 

  338.             if ($parts === FALSE){

    339. 

  339.                 error('invalidurl');

    340. 

  340.             }

    341. 

  341.             if (isset($parts['query'])){

    342. 

  342.                 parse_str(str_replace('&amp;', '&', $parts['query']), $this->params);

    343. 

  343.             }

    344. 

  344.             unset($parts['query']);

    345. 

  345.             foreach ($parts as $key => $value){

    346. 

  346.                 $this->$key = $value;

    347. 

  347.             }

    348. 

  348.             $this->params($params);

    349. 

  349.         }

    350. 

  350.     }

    351. 

  351. 

    352. 

  352.     /**

    353. 

  353.      * Add an array of params to the params for this page.

    354. 

  354.      *

    355. 

  355.      * The added params override existing ones if they have the same name.

    356. 

  356.      *

    357. 

  357.      * @param array $params Defaults to null. If null then return value of param 'name'.

    358. 

  358.      * @return array Array of Params for url.

    359. 

  359.      */

    360. 

  360.     function params($params = null) {

    361. 

  361.         if (!is_null($params)) {

    362. 

  362.             return $this->params = $params + $this->params;

    363. 

  363.         } else {

    364. 

  364.             return $this->params;

    365. 

  365.         }

    366. 

  366.     }

    367. 

  367. 

    368. 

  368.     /**

    369. 

  369.      * Remove all params if no arguments passed. Or else remove param $arg1, $arg2, etc.

    370. 

  370.      *

    371. 

  371.      * @param string $arg1

    372. 

  372.      * @param string $arg2

    373. 

  373.      * @param string $arg3

    374. 

  374.      */

    375. 

  375.     function remove_params(){

    376. 

  376.         if ($thisargs = func_get_args()){

    377. 

  377.             foreach ($thisargs as $arg){

    378. 

  378.                 if (isset($this->params[$arg])){

    379. 

  379.                     unset($this->params[$arg]);

    380. 

  380.                 }

    381. 

  381.             }

    382. 

  382.         } else { // no args

    383. 

  383.             $this->params = array();

    384. 

  384.         }

    385. 

  385.     }

    386. 

  386. 

    387. 

  387.     /**

    388. 

  388.      * Add a param to the params for this page. The added param overrides existing one if they

    389. 

  389.      * have the same name.

    390. 

  390.      *

    391. 

  391.      * @param string $paramname name

    392. 

  392.      * @param string $param value

    393. 

  393.      */

    394. 

  394.     function param($paramname, $param){

    395. 

  395.         $this->params = array($paramname => $param) + $this->params;

    396. 

  396.     }

    397. 

  397. 

    398. 

  398. 

    399. 

  399.     function get_query_string($overrideparams = array()){

    400. 

  400.         $arr = array();

    401. 

  401.         $params = $overrideparams + $this->params;

    402. 

  402.         foreach ($params as $key => $val){

    403. 

  403.            $arr[] = urlencode($key)."=".urlencode($val);

    404. 

  404.         }

    405. 

  405.         return implode($arr, "&amp;");

    406. 

  406.     }

    407. 

  407.     /**

    408. 

  408.      * Outputs params as hidden form elements.

    409. 

  409.      *

    410. 

  410.      * @param  array $exclude params to ignore

    411. 

  411.      * @param integer $indent indentation

    412. 

  412.      * @param array $overrideparams params to add to the output params, these

    413. 

  413.      * override existing ones with the same name.

    414. 

  414.      * @return string html for form elements.

    415. 

  415.      */

    416. 

  416.     function hidden_params_out($exclude = array(), $indent = 0, $overrideparams=array()){

    417. 

  417.         $tabindent = str_repeat("\t", $indent);

    418. 

  418.         $str = '';

    419. 

  419.         $params = $overrideparams + $this->params;

    420. 

  420.         foreach ($params as $key => $val){

    421. 

  421.             if (FALSE === array_search($key, $exclude)) {

    422. 

  422.                 $val = s($val);

    423. 

  423.                 $str.= "$tabindent<input type=\"hidden\" name=\"$key\" value=\"$val\" />\n";

    424. 

  424.             }

    425. 

  425.         }

    426. 

  426.         return $str;

    427. 

  427.     }

    428. 

  428.     /**

    429. 

  429.      * Output url

    430. 

  430.      *

    431. 

  431.      * @param boolean $noquerystring whether to output page params as a query string in the url.

    432. 

  432.      * @param array $overrideparams params to add to the output url, these override existing ones with the same name.

    433. 

  433.      * @return string url

    434. 

  434.      */

    435. 

  435.     function out($noquerystring = false, $overrideparams = array()) {

    436. 

  436.         $uri = $this->scheme ? $this->scheme.':'.((strtolower($this->scheme) == 'mailto') ? '':'//'): '';

    437. 

  437.         $uri .= $this->user ? $this->user.($this->pass? ':'.$this->pass:'').'@':'';

    438. 

  438.         $uri .= $this->host ? $this->host : '';

    439. 

  439.         $uri .= $this->port ? ':'.$this->port : '';

    440. 

  440.         $uri .= $this->path ? $this->path : '';

    441. 

  441.         if (!$noquerystring){

    442. 

  442.             $uri .= (count($this->params)||count($overrideparams)) ? '?'.$this->get_query_string($overrideparams) : '';

    443. 

  443.         }

    444. 

  444.         $uri .= $this->fragment ? '#'.$this->fragment : '';

    445. 

  445.         return $uri;

    446. 

  446.     }

    447. 

  447.     /**

    448. 

  448.      * Output action url with sesskey

    449. 

  449.      *

    450. 

  450.      * @param boolean $noquerystring whether to output page params as a query string in the url.

    451. 

  451.      * @return string url

    452. 

  452.      */

    453. 

  453.     function out_action($overrideparams = array()) {

    454. 

  454.         $overrideparams = array('sesskey'=> sesskey()) + $overrideparams;

    455. 

  455.         return $this->out(false, $overrideparams);

    456. 

  456.     }

    457. 

  457. }

    458. 

  458. 

    459. 

  459. /**

    460. 

  460.  * Determine if there is data waiting to be processed from a form

    461. 

  461.  *

    462. 

  462.  * Used on most forms in Moodle to check for data

    463. 

  463.  * Returns the data as an object, if it's found.

    464. 

  464.  * This object can be used in foreach loops without

    465. 

  465.  * casting because it's cast to (array) automatically

    466. 

  466.  *

    467. 

  467.  * Checks that submitted POST data exists and returns it as object.

    468. 

  468.  *

    469. 

  469.  * @param string $url not used anymore

    470. 

  470.  * @return mixed false or object

    471. 

  471.  */

    472. 

  472. function data_submitted($url='') {

    473. 

  473. 

    474. 

  474.     if (empty($_POST)) {

    475. 

  475.         return false;

    476. 

  476.     } else {

    477. 

  477.         return (object)$_POST;

    478. 

  478.     }

    479. 

  479. }

    480. 

  480. 

    481. 

  481. /**

    482. 

  482.  * Moodle replacement for php stripslashes() function,

    483. 

  483.  * works also for objects and arrays.

    484. 

  484.  *

    485. 

  485.  * The standard php stripslashes() removes ALL backslashes

    486. 

  486.  * even from strings - so  C:\temp becomes C:temp - this isn't good.

    487. 

  487.  * This function should work as a fairly safe replacement

    488. 

  488.  * to be called on quoted AND unquoted strings (to be sure)

    489. 

  489.  *

    490. 

  490.  * @param mixed something to remove unsafe slashes from

    491. 

  491.  * @return mixed

    492. 

  492.  */

    493. 

  493. function stripslashes_safe($mixed) {

    494. 

  494.     // there is no need to remove slashes from int, float and bool types

    495. 

  495.     if (empty($mixed)) {

    496. 

  496.         //nothing to do...

    497. 

  497.     } else if (is_string($mixed)) {

    498. 

  498.         if (ini_get_bool('magic_quotes_sybase')) { //only unescape single quotes

    499. 

  499.             $mixed = str_replace("''", "'", $mixed);

    500. 

  500.         } else { //the rest, simple and double quotes and backslashes

    501. 

  501.             $mixed = str_replace("\\'", "'", $mixed);

    502. 

  502.             $mixed = str_replace('\\"', '"', $mixed);

    503. 

  503.             $mixed = str_replace('\\\\', '\\', $mixed);

    504. 

  504.         }

    505. 

  505.     } else if (is_array($mixed)) {

    506. 

  506.         foreach ($mixed as $key => $value) {

    507. 

  507.             $mixed[$key] = stripslashes_safe($value);

    508. 

  508.         }

    509. 

  509.     } else if (is_object($mixed)) {

    510. 

  510.         $vars = get_object_vars($mixed);

    511. 

  511.         foreach ($vars as $key => $value) {

    512. 

  512.             $mixed->$key = stripslashes_safe($value);

    513. 

  513.         }

    514. 

  514.     }

    515. 

  515. 

    516. 

  516.     return $mixed;

    517. 

  517. }

    518. 

  518. 

    519. 

  519. /**

    520. 

  520.  * Recursive implementation of stripslashes()

    521. 

  521.  *

    522. 

  522.  * This function will allow you to strip the slashes from a variable.

    523. 

  523.  * If the variable is an array or object, slashes will be stripped

    524. 

  524.  * from the items (or properties) it contains, even if they are arrays

    525. 

  525.  * or objects themselves.

    526. 

  526.  *

    527. 

  527.  * @param mixed the variable to remove slashes from

    528. 

  528.  * @return mixed

    529. 

  529.  */

    530. 

  530. function stripslashes_recursive($var) {

    531. 

  531.     if (is_object($var)) {

    532. 

  532.         $new_var = new object();

    533. 

  533.         $properties = get_object_vars($var);

    534. 

  534.         foreach($properties as $property => $value) {

    535. 

  535.             $new_var->$property = stripslashes_recursive($value);

    536. 

  536.         }

    537. 

  537. 

    538. 

  538.     } else if(is_array($var)) {

    539. 

  539.         $new_var = array();

    540. 

  540.         foreach($var as $property => $value) {

    541. 

  541.             $new_var[$property] = stripslashes_recursive($value);

    542. 

  542.         }

    543. 

  543. 

    544. 

  544.     } else if(is_string($var)) {

    545. 

  545.         $new_var = stripslashes($var);

    546. 

  546. 

    547. 

  547.     } else {

    548. 

  548.         $new_var = $var;

    549. 

  549.     }

    550. 

  550. 

    551. 

  551.     return $new_var;

    552. 

  552. }

    553. 

  553. 

    554. 

  554. /**

    555. 

  555.  * Recursive implementation of addslashes()

    556. 

  556.  *

    557. 

  557.  * This function will allow you to add the slashes from a variable.

    558. 

  558.  * If the variable is an array or object, slashes will be added

    559. 

  559.  * to the items (or properties) it contains, even if they are arrays

    560. 

  560.  * or objects themselves.

    561. 

  561.  *

    562. 

  562.  * @param mixed the variable to add slashes from

    563. 

  563.  * @return mixed

    564. 

  564.  */

    565. 

  565. function addslashes_recursive($var) {

    566. 

  566.     if (is_object($var)) {

    567. 

  567.         $new_var = new object();

    568. 

  568.         $properties = get_object_vars($var);

    569. 

  569.         foreach($properties as $property => $value) {

    570. 

  570.             $new_var->$property = addslashes_recursive($value);

    571. 

  571.         }

    572. 

  572. 

    573. 

  573.     } else if (is_array($var)) {

    574. 

  574.         $new_var = array();

    575. 

  575.         foreach($var as $property => $value) {

    576. 

  576.             $new_var[$property] = addslashes_recursive($value);

    577. 

  577.         }

    578. 

  578. 

    579. 

  579.     } else if (is_string($var)) {

    580. 

  580.         $new_var = addslashes($var);

    581. 

  581. 

    582. 

  582.     } else { // nulls, integers, etc.

    583. 

  583.         $new_var = $var;

    584. 

  584.     }

    585. 

  585. 

    586. 

  586.     return $new_var;

    587. 

  587. }

    588. 

  588. 

    589. 

  589. /**

    590. 

  590.  * Given some normal text this function will break up any

    591. 

  591.  * long words to a given size by inserting the given character

    592. 

  592.  *

    593. 

  593.  * It's multibyte savvy and doesn't change anything inside html tags.

    594. 

  594.  *

    595. 

  595.  * @param string $string the string to be modified

    596. 

  596.  * @param int $maxsize maximum length of the string to be returned

    597. 

  597.  * @param string $cutchar the string used to represent word breaks

    598. 

  598.  * @return string

    599. 

  599.  */

    600. 

  600. function break_up_long_words($string, $maxsize=20, $cutchar=' ') {

    601. 

  601. 

    602. 

  602. /// Loading the textlib singleton instance. We are going to need it.

    603. 

  603.     $textlib = textlib_get_instance();

    604. 

  604. 

    605. 

  605. /// First of all, save all the tags inside the text to skip them

    606. 

  606.     $tags = array();

    607. 

  607.     filter_save_tags($string,$tags);

    608. 

  608. 

    609. 

  609. /// Process the string adding the cut when necessary

    610. 

  610.     $output = '';

    611. 

  611.     $length = $textlib->strlen($string);

    612. 

  612.     $wordlength = 0;

    613. 

  613. 

    614. 

  614.     for ($i=0; $i<$length; $i++) {

    615. 

  615.         $char = $textlib->substr($string, $i, 1);

    616. 

  616.         if ($char == ' ' or $char == "\t" or $char == "\n" or $char == "\r" or $char == "<" or $char == ">") {

    617. 

  617.             $wordlength = 0;

    618. 

  618.         } else {

    619. 

  619.             $wordlength++;

    620. 

  620.             if ($wordlength > $maxsize) {

    621. 

  621.                 $output .= $cutchar;

    622. 

  622.                 $wordlength = 0;

    623. 

  623.             }

    624. 

  624.         }

    625. 

  625.         $output .= $char;

    626. 

  626.     }

    627. 

  627. 

    628. 

  628. /// Finally load the tags back again

    629. 

  629.     if (!empty($tags)) {

    630. 

  630.         $output = str_replace(array_keys($tags), $tags, $output);

    631. 

  631.     }

    632. 

  632. 

    633. 

  633.     return $output;

    634. 

  634. }

    635. 

  635. 

    636. 

  636. /**

    637. 

  637.  * This does a search and replace, ignoring case

    638. 

  638.  * This function is only used for versions of PHP older than version 5

    639. 

  639.  * which do not have a native version of this function.

    640. 

  640.  * Taken from the PHP manual, by bradhuizenga @ softhome.net

    641. 

  641.  *

    642. 

  642.  * @param string $find the string to search for

    643. 

  643.  * @param string $replace the string to replace $find with

    644. 

  644.  * @param string $string the string to search through

    645. 

  645.  * return string

    646. 

  646.  */

    647. 

  647. if (!function_exists('str_ireplace')) {    /// Only exists in PHP 5

    648. 

  648.     function str_ireplace($find, $replace, $string) {

    649. 

  649. 

    650. 

  650.         if (!is_array($find)) {

    651. 

  651.             $find = array($find);

    652. 

  652.         }

    653. 

  653. 

    654. 

  654.         if(!is_array($replace)) {

    655. 

  655.             if (!is_array($find)) {

    656. 

  656.                 $replace = array($replace);

    657. 

  657.             } else {

    658. 

  658.                 // this will duplicate the string into an array the size of $find

    659. 

  659.                 $c = count($find);

    660. 

  660.                 $rString = $replace;

    661. 

  661.                 unset($replace);

    662. 

  662.                 for ($i = 0; $i < $c; $i++) {

    663. 

  663.                     $replace[$i] = $rString;

    664. 

  664.                 }

    665. 

  665.             }

    666. 

  666.         }

    667. 

  667. 

    668. 

  668.         foreach ($find as $fKey => $fItem) {

    669. 

  669.             $between = explode(strtolower($fItem),strtolower($string));

    670. 

  670.             $pos = 0;

    671. 

  671.             foreach($between as $bKey => $bItem) {

    672. 

  672.                 $between[$bKey] = substr($string,$pos,strlen($bItem));

    673. 

  673.                 $pos += strlen($bItem) + strlen($fItem);

    674. 

  674.             }

    675. 

  675.             $string = implode($replace[$fKey],$between);

    676. 

  676.         }

    677. 

  677.         return ($string);

    678. 

  678.     }

    679. 

  679. }

    680. 

  680. 

    681. 

  681. /**

    682. 

  682.  * Locate the position of a string in another string

    683. 

  683.  *

    684. 

  684.  * This function is only used for versions of PHP older than version 5

    685. 

  685.  * which do not have a native version of this function.

    686. 

  686.  * Taken from the PHP manual, by dmarsh @ spscc.ctc.edu

    687. 

  687.  *

    688. 

  688.  * @param string $haystack The string to be searched

    689. 

  689.  * @param string $needle The string to search for

    690. 

  690.  * @param int $offset The position in $haystack where the search should begin.

    691. 

  691.  */

    692. 

  692. if (!function_exists('stripos')) {    /// Only exists in PHP 5

    693. 

  693.     function stripos($haystack, $needle, $offset=0) {

    694. 

  694. 

    695. 

  695.         return strpos(strtoupper($haystack), strtoupper($needle), $offset);

    696. 

  696.     }

    697. 

  697. }

    698. 

  698. 

    699. 

  699. /**

    700. 

  700.  * This function will print a button/link/etc. form element

    701. 

  701.  * that will work on both Javascript and non-javascript browsers.

    702. 

  702.  * Relies on the Javascript function openpopup in javascript.php

    703. 

  703.  *

    704. 

  704.  * All parameters default to null, only $type and $url are mandatory.

    705. 

  705.  *

    706. 

  706.  * $url must be relative to home page  eg /mod/survey/stuff.php

    707. 

  707.  * @param string $url Web link relative to home page

    708. 

  708.  * @param string $name Name to be assigned to the popup window (this is used by

    709. 

  709.  *   client-side scripts to "talk" to the popup window)

    710. 

  710.  * @param string $linkname Text to be displayed as web link

    711. 

  711.  * @param int $height Height to assign to popup window

    712. 

  712.  * @param int $width Height to assign to popup window

    713. 

  713.  * @param string $title Text to be displayed as popup page title

    714. 

  714.  * @param string $options List of additional options for popup window

    715. 

  715.  * @param string $return If true, return as a string, otherwise print

    716. 

  716.  * @param string $id id added to the element

    717. 

  717.  * @param string $class class added to the element

    718. 

  718.  * @return string

    719. 

  719.  * @uses $CFG

    720. 

  720.  */

    721. 

  721. function element_to_popup_window ($type=null, $url=null, $name=null, $linkname=null,

    722. 

  722.                                   $height=400, $width=500, $title=null,

    723. 

  723.                                   $options=null, $return=false, $id=null, $class=null) {

    724. 

  724. 

    725. 

  725.     if (is_null($url)) {

    726. 

  726.         debugging('You must give the url to display in the popup. URL is missing - can\'t create popup window.', DEBUG_DEVELOPER);

    727. 

  727.     }

    728. 

  728. 

    729. 

  729.     global $CFG;

    730. 

  730. 

    731. 

  731.     if ($options == 'none') { // 'none' is legacy, should be removed in v2.0

    732. 

  732.         $options = null;

    733. 

  733.     }

    734. 

  734. 

    735. 

  735.     // add some sane default options for popup windows

    736. 

  736.     if (!$options) {

    737. 

  737.         $options = 'menubar=0,location=0,scrollbars,resizable';

    738. 

  738.     }

    739. 

  739.     if ($width) {

    740. 

  740.         $options .= ',width='. $width;

    741. 

  741.     }

    742. 

  742.     if ($height) {

    743. 

  743.         $options .= ',height='. $height;

    744. 

  744.     }

    745. 

  745.     if ($id) {

    746. 

  746.         $id = ' id="'.$id.'" ';

    747. 

  747.     }

    748. 

  748.     if ($class) {

    749. 

  749.         $class = ' class="'.$class.'" ';

    750. 

  750.     }

    751. 

  751.     if ($name) {

    752. 

  752.         $_name = $name;

    753. 

  753.         if (($name = preg_replace("/\s/", '_', $name)) != $_name) {

    754. 

  754.             debugging('The $name of a popup window shouldn\'t contain spaces - string modified. '. $_name .' changed to '. $name, DEBUG_DEVELOPER);

    755. 

  755.         }

    756. 

  756.     } else {

    757. 

  757.         $name = 'popup';

    758. 

  758.     }

    759. 

  759. 

    760. 

  760.     // get some default string, using the localized version of legacy defaults

    761. 

  761.     if (is_null($linkname) || $linkname === '') {

    762. 

  762.         $linkname = get_string('clickhere');

    763. 

  763.     }

    764. 

  764.     if (!$title) {

    765. 

  765.         $title = get_string('popupwindowname');

    766. 

  766.     }

    767. 

  767. 

    768. 

  768.     $fullscreen = 0; // must be passed to openpopup

    769. 

  769.     $element = '';

    770. 

  770. 

    771. 

  771.     switch ($type) {

    772. 

  772.         case 'button' :

    773. 

  773.             $element = '<input type="button" name="'. $name .'" title="'. $title .'" value="'. $linkname .'" '. $id . $class .

    774. 

  774.                        "onclick=\"return openpopup('$url', '$name', '$options', $fullscreen);\" />\n";

    775. 

  775.             break;

    776. 

  776.         case 'link' :

    777. 

  777.             // some log url entries contain _SERVER[HTTP_REFERRER] in which case wwwroot is already there.

    778. 

  778.             if (!(strpos($url,$CFG->wwwroot) === false)) {

    779. 

  779.                 $url = substr($url, strlen($CFG->wwwroot));

    780. 

  780.             }

    781. 

  781.             $element = '<a title="'. s(strip_tags($title)) .'" href="'. $CFG->wwwroot . $url .'" '.

    782. 

  782.                        "$CFG->frametarget onclick=\"this.target='$name'; return openpopup('$url', '$name', '$options', $fullscreen);\">$linkname</a>";

    783. 

  783.             break;

    784. 

  784.         default :

    785. 

  785.             error('Undefined element - can\'t create popup window.');

    786. 

  786.             break;

    787. 

  787.     }

    788. 

  788. 

    789. 

  789.     if ($return) {

    790. 

  790.         return $element;

    791. 

  791.     } else {

    792. 

  792.         echo $element;

    793. 

  793.     }

    794. 

  794. }

    795. 

  795. 

    796. 

  796. /**

    797. 

  797.  * Creates and displays (or returns) a link to a popup window, using element_to_popup_window function.

    798. 

  798.  *

    799. 

  799.  * @return string html code to display a link to a popup window.

    800. 

  800.  * @see element_to_popup_window()

    801. 

  801.  */

    802. 

  802. function link_to_popup_window ($url, $name=null, $linkname=null,

    803. 

  803.                                $height=400, $width=500, $title=null,

    804. 

  804.                                $options=null, $return=false) {

    805. 

  805. 

    806. 

  806.     return element_to_popup_window('link', $url, $name, $linkname, $height, $width, $title, $options, $return, null, null);

    807. 

  807. }

    808. 

  808. 

    809. 

  809. /**

    810. 

  810.  * Creates and displays (or returns) a buttons to a popup window, using element_to_popup_window function.

    811. 

  811.  *

    812. 

  812.  * @return string html code to display a button to a popup window.

    813. 

  813.  * @see element_to_popup_window()

    814. 

  814.  */

    815. 

  815. function button_to_popup_window ($url, $name=null, $linkname=null,

    816. 

  816.                                  $height=400, $width=500, $title=null, $options=null, $return=false,

    817. 

  817.                                  $id=null, $class=null) {

    818. 

  818. 

    819. 

  819.     return element_to_popup_window('button', $url, $name, $linkname, $height, $width, $title, $options, $return, $id, $class);

    820. 

  820. }

    821. 

  821. 

    822. 

  822. 

    823. 

  823. /**

    824. 

  824.  * Prints a simple button to close a window

    825. 

  825.  * @param string $name name of the window to close

    826. 

  826.  * @param boolean $return whether this function should return a string or output it

    827. 

  827.  * @return string if $return is true, nothing otherwise

    828. 

  828.  */

    829. 

  829. function close_window_button($name='closewindow', $return=false) {

    830. 

  830.     global $CFG;

    831. 

  831. 

    832. 

  832.     $output = '';

    833. 

  833. 

    834. 

  834.     $output .= '<div class="closewindow">' . "\n";

    835. 

  835.     $output .= '<form action="#"><div>';

    836. 

  836.     $output .= '<input type="button" onclick="self.close();" value="'.get_string($name).'" />';

    837. 

  837.     $output .= '</div></form>';

    838. 

  838.     $output .= '</div>' . "\n";

    839. 

  839. 

    840. 

  840.     if ($return) {

    841. 

  841.         return $output;

    842. 

  842.     } else {

    843. 

  843.         echo $output;

    844. 

  844.     }

    845. 

  845. }

    846. 

  846. 

    847. 

  847. /*

    848. 

  848.  * Try and close the current window immediately using Javascript

    849. 

  849.  * @param int $delay the delay in seconds before closing the window

    850. 

  850.  */

    851. 

  851. function close_window($delay=0) {

    852. 

  852. ?>

    853. 

  853. <script type="text/javascript">

    854. 

  854. //<![CDATA[

    855. 

  855.     function close_this_window() {

    856. 

  856.         self.close();

    857. 

  857.     }

    858. 

  858.     setTimeout("close_this_window()", <?php echo $delay * 1000 ?>);

    859. 

  859. //]]>

    860. 

  860. </script>

    861. 

  861. <noscript><center>

    862. 

  862. <?php print_string('pleaseclose') ?>

    863. 

  863. </center></noscript>

    864. 

  864. <?php

    865. 

  865.     die;

    866. 

  866. }

    867. 

  867. 

    868. 

  868. /**

    869. 

  869.  * Given an array of values, output the HTML for a select element with those options.

    870. 

  870.  * Normally, you only need to use the first few parameters.

    871. 

  871.  *

    872. 

  872.  * @param array $options The options to offer. An array of the form

    873. 

  873.  *      $options[{value}] = {text displayed for that option};

    874. 

  874.  * @param string $name the name of this form control, as in &lt;select name="..." ...

    875. 

  875.  * @param string $selected the option to select initially, default none.

    876. 

  876.  * @param string $nothing The label for the 'nothing is selected' option. Defaults to get_string('choose').

    877. 

  877.  *      Set this to '' if you don't want a 'nothing is selected' option.

    878. 

  878.  * @param string $script in not '', then this is added to the &lt;select> element as an onchange handler.

    879. 

  879.  * @param string $nothingvalue The value corresponding to the $nothing option. Defaults to 0.

    880. 

  880.  * @param boolean $return if false (the default) the the output is printed directly, If true, the

    881. 

  881.  *      generated HTML is returned as a string.

    882. 

  882.  * @param boolean $disabled if true, the select is generated in a disabled state. Default, false.

    883. 

  883.  * @param int $tabindex if give, sets the tabindex attribute on the &lt;select> element. Default none.

    884. 

  884.  * @param string $id value to use for the id attribute of the &lt;select> element. If none is given,

    885. 

  885.  *      then a suitable one is constructed.

    886. 

  886.  * @param mixed $listbox if false, display as a dropdown menu. If true, display as a list box.

    887. 

  887.  *      By default, the list box will have a number of rows equal to min(10, count($options)), but if

    888. 

  888.  *      $listbox is an integer, that number is used for size instead.

    889. 

  889.  * @param boolean $multiple if true, enable multiple selections, else only 1 item can be selected. Used

    890. 

  890.  *      when $listbox display is enabled

    891. 

  891.  * @param string $class value to use for the class attribute of the &lt;select> element. If none is given,

    892. 

  892.  *      then a suitable one is constructed.

    893. 

  893.  */

    894. 

  894. function choose_from_menu ($options, $name, $selected='', $nothing='choose', $script='',

    895. 

  895.                            $nothingvalue='0', $return=false, $disabled=false, $tabindex=0,

    896. 

  896.                            $id='', $listbox=false, $multiple=false, $class='') {

    897. 

  897. 

    898. 

  898.     if ($nothing == 'choose') {

    899. 

  899.         $nothing = get_string('choose') .'...';

    900. 

  900.     }

    901. 

  901. 

    902. 

  902.     $attributes = ($script) ? 'onchange="'. $script .'"' : '';

    903. 

  903.     if ($disabled) {

    904. 

  904.         $attributes .= ' disabled="disabled"';

    905. 

  905.     }

    906. 

  906. 

    907. 

  907.     if ($tabindex) {

    908. 

  908.         $attributes .= ' tabindex="'.$tabindex.'"';

    909. 

  909.     }

    910. 

  910. 

    911. 

  911.     if ($id ==='') {

    912. 

  912.         $id = 'menu'.$name;

    913. 

  913.         // name may contaion [], which would make an invalid id. e.g. numeric question type editing form, assignment quickgrading

    914. 

  914.         $id = str_replace('[', '', $id);

    915. 

  915.         $id = str_replace(']', '', $id);

    916. 

  916.     }

    917. 

  917. 

    918. 

  918.     if ($class ==='') {

    919. 

  919.         $class = 'menu'.$name;

    920. 

  920.         // name may contaion [], which would make an invalid class. e.g. numeric question type editing form, assignment quickgrading

    921. 

  921.         $class = str_replace('[', '', $class);

    922. 

  922.         $class = str_replace(']', '', $class);

    923. 

  923.     }

    924. 

  924.     $class = 'select ' . $class; /// Add 'select' selector always

    925. 

  925. 

    926. 

  926.     if ($listbox) {

    927. 

  927.         if (is_integer($listbox)) {

    928. 

  928.             $size = $listbox;

    929. 

  929.         } else {

    930. 

  930.             $numchoices = count($options);

    931. 

  931.             if ($nothing) {

    932. 

  932.                 $numchoices += 1;

    933. 

  933.             }

    934. 

  934.             $size = min(10, $numchoices);

    935. 

  935.         }

    936. 

  936.         $attributes .= ' size="' . $size . '"';

    937. 

  937.         if ($multiple) {

    938. 

  938.             $attributes .= ' multiple="multiple"';

    939. 

  939.         }

    940. 

  940.     }

    941. 

  941. 

    942. 

  942.     $output = '<select id="'. $id .'" class="'. $class .'" name="'. $name .'" '. $attributes .'>' . "\n";

    943. 

  943.     if ($nothing) {

    944. 

  944.         $output .= '   <option value="'. s($nothingvalue) .'"'. "\n";

    945. 

  945.         if ($nothingvalue === $selected) {

    946. 

  946.             $output .= ' selected="selected"';

    947. 

  947.         }

    948. 

  948.         $output .= '>'. $nothing .'</option>' . "\n";

    949. 

  949.     }

    950. 

  950. 

    951. 

  951.     if (!empty($options)) {

    952. 

  952.         foreach ($options as $value => $label) {

    953. 

  953.             $output .= '   <option value="'. s($value) .'"';

    954. 

  954.             if ((string)$value == (string)$selected ||

    955. 

  955.                     (is_array($selected) && in_array($value, $selected))) {

    956. 

  956.                 $output .= ' selected="selected"';

    957. 

  957.             }

    958. 

  958.             if ($label === '') {

    959. 

  959.                 $output .= '>'. $value .'</option>' . "\n";

    960. 

  960.             } else {

    961. 

  961.                 $output .= '>'. $label .'</option>' . "\n";

    962. 

  962.             }

    963. 

  963.         }

    964. 

  964.     }

    965. 

  965.     $output .= '</select>' . "\n";

    966. 

  966. 

    967. 

  967.     if ($return) {

    968. 

  968.         return $output;

    969. 

  969.     } else {

    970. 

  970.         echo $output;

    971. 

  971.     }

    972. 

  972. }

    973. 

  973. 

    974. 

  974. /**

    975. 

  975.  * Choose value 0 or 1 from a menu with options 'No' and 'Yes'.

    976. 

  976.  * Other options like choose_from_menu.

    977. 

  977.  * @param string $name

    978. 

  978.  * @param string $selected

    979. 

  979.  * @param string $string (defaults to '')

    980. 

  980.  * @param boolean $return whether this function should return a string or output it (defaults to false)

    981. 

  981.  * @param boolean $disabled (defaults to false)

    982. 

  982.  * @param int $tabindex

    983. 

  983.  */

    984. 

  984. function choose_from_menu_yesno($name, $selected, $script = '',

    985. 

  985.         $return = false, $disabled = false, $tabindex = 0) {

    986. 

  986.     return choose_from_menu(array(get_string('no'), get_string('yes')), $name,

    987. 

  987.             $selected, '', $script, '0', $return, $disabled, $tabindex);

    988. 

  988. }

    989. 

  989. 

    990. 

  990. /**

    991. 

  991.  * Just like choose_from_menu, but takes a nested array (2 levels) and makes a dropdown menu

    992. 

  992.  * including option headings with the first level.

    993. 

  993.  */

    994. 

  994. function choose_from_menu_nested($options,$name,$selected='',$nothing='choose',$script = '',

    995. 

  995.                                  $nothingvalue=0,$return=false,$disabled=false,$tabindex=0) {

    996. 

  996. 

    997. 

  997.    if ($nothing == 'choose') {

    998. 

  998.         $nothing = get_string('choose') .'...';

    999. 

  999.     }

    1000. 

  1000. 

    1001. 

  1001.     $attributes = ($script) ? 'onchange="'. $script .'"' : '';

    1002. 

  1002.     if ($disabled) {

    1003. 

  1003.         $attributes .= ' disabled="disabled"';

    1004. 

  1004.     }

    1005. 

  1005. 

    1006. 

  1006.     if ($tabindex) {

    1007. 

  1007.         $attributes .= ' tabindex="'.$tabindex.'"';

    1008. 

  1008.     }

    1009. 

  1009. 

    1010. 

  1010.     $output = '<select id="menu'.$name.'" name="'. $name .'" '. $attributes .'>' . "\n";

    1011. 

  1011.     if ($nothing) {

    1012. 

  1012.         $output .= '   <option value="'. $nothingvalue .'"'. "\n";

    1013. 

  1013.         if ($nothingvalue === $selected) {

    1014. 

  1014.             $output .= ' selected="selected"';

    1015. 

  1015.         }

    1016. 

  1016.         $output .= '>'. $nothing .'</option>' . "\n";

    1017. 

  1017.     }

    1018. 

  1018.     if (!empty($options)) {

    1019. 

  1019.         foreach ($options as $section => $values) {

    1020. 

  1020.             $output .= '   <optgroup label="'. s(strip_tags(format_string($section))) .'">'."\n";

    1021. 

  1021.             foreach ($values as $value => $label) {

    1022. 

  1022.                 $output .= '   <option value="'. format_string($value) .'"';

    1023. 

  1023.                 if ((string)$value == (string)$selected) {

    1024. 

  1024.                     $output .= ' selected="selected"';

    1025. 

  1025.                 }

    1026. 

  1026.                 if ($label === '') {

    1027. 

  1027.                     $output .= '>'. $value .'</option>' . "\n";

    1028. 

  1028.                 } else {

    1029. 

  1029.                     $output .= '>'. $label .'</option>' . "\n";

    1030. 

  1030.                 }

    1031. 

  1031.             }

    1032. 

  1032.             $output .= '   </optgroup>'."\n";

    1033. 

  1033.         }

    1034. 

  1034.     }

    1035. 

  1035.     $output .= '</select>' . "\n";

    1036. 

  1036. 

    1037. 

  1037.     if ($return) {

    1038. 

  1038.         return $output;

    1039. 

  1039.     } else {

    1040. 

  1040.         echo $output;

    1041. 

  1041.     }

    1042. 

  1042. }

    1043. 

  1043. 

    1044. 

  1044. 

    1045. 

  1045. /**

    1046. 

  1046.  * Given an array of values, creates a group of radio buttons to be part of a form

    1047. 

  1047.  *

    1048. 

  1048.  * @param array  $options  An array of value-label pairs for the radio group (values as keys)

    1049. 

  1049.  * @param string $name     Name of the radiogroup (unique in the form)

    1050. 

  1050.  * @param string $checked  The value that is already checked

    1051. 

  1051.  */

    1052. 

  1052. function choose_from_radio ($options, $name, $checked='', $return=false) {

    1053. 

  1053. 

    1054. 

  1054.     static $idcounter = 0;

    1055. 

  1055. 

    1056. 

  1056.     if (!$name) {

    1057. 

  1057.         $name = 'unnamed';

    1058. 

  1058.     }

    1059. 

  1059. 

    1060. 

  1060.     $output = '<span class="radiogroup '.$name."\">\n";

    1061. 

  1061. 

    1062. 

  1062.     if (!empty($options)) {

    1063. 

  1063.         $currentradio = 0;

    1064. 

  1064.         foreach ($options as $value => $label) {

    1065. 

  1065.             $htmlid = 'auto-rb'.sprintf('%04d', ++$idcounter);

    1066. 

  1066.             $output .= ' <span class="radioelement '.$name.' rb'.$currentradio."\">";

    1067. 

  1067.             $output .= '<input name="'.$name.'" id="'.$htmlid.'" type="radio" value="'.$value.'"';

    1068. 

  1068.             if ($value == $checked) {

    1069. 

  1069.                 $output .= ' checked="checked"';

    1070. 

  1070.             }

    1071. 

  1071.             if ($label === '') {

    1072. 

  1072.                 $output .= ' /> <label for="'.$htmlid.'">'.  $value .'</label></span>' .  "\n";

    1073. 

  1073.             } else {

    1074. 

  1074.                 $output .= ' /> <label for="'.$htmlid.'">'.  $label .'</label></span>' .  "\n";

    1075. 

  1075.             }

    1076. 

  1076.             $currentradio = ($currentradio + 1) % 2;

    1077. 

  1077.         }

    1078. 

  1078.     }

    1079. 

  1079. 

    1080. 

  1080.     $output .= '</span>' .  "\n";

    1081. 

  1081. 

    1082. 

  1082.     if ($return) {

    1083. 

  1083.         return $output;

    1084. 

  1084.     } else {

    1085. 

  1085.         echo $output;

    1086. 

  1086.     }

    1087. 

  1087. }

    1088. 

  1088. 

    1089. 

  1089. /** Display an standard html checkbox with an optional label

    1090. 

  1090.  *

    1091. 

  1091.  * @param string  $name    The name of the checkbox

    1092. 

  1092.  * @param string  $value   The valus that the checkbox will pass when checked

    1093. 

  1093.  * @param boolean $checked The flag to tell the checkbox initial state

    1094. 

  1094.  * @param string  $label   The label to be showed near the checkbox

    1095. 

  1095.  * @param string  $alt     The info to be inserted in the alt tag

    1096. 

  1096.  */

    1097. 

  1097. function print_checkbox ($name, $value, $checked = true, $label = '', $alt = '', $script='',$return=false) {

    1098. 

  1098. 

    1099. 

  1099.     static $idcounter = 0;

    1100. 

  1100. 

    1101. 

  1101.     if (!$name) {

    1102. 

  1102.         $name = 'unnamed';

    1103. 

  1103.     }

    1104. 

  1104. 

    1105. 

  1105.     if ($alt) {

    1106. 

  1106.         $alt = strip_tags($alt);

    1107. 

  1107.     } else {

    1108. 

  1108.         $alt = 'checkbox';

    1109. 

  1109.     }

    1110. 

  1110. 

    1111. 

  1111.     if ($checked) {

    1112. 

  1112.         $strchecked = ' checked="checked"';

    1113. 

  1113.     } else {

    1114. 

  1114.         $strchecked = '';

    1115. 

  1115.     }

    1116. 

  1116. 

    1117. 

  1117.     $htmlid = 'auto-cb'.sprintf('%04d', ++$idcounter);

    1118. 

  1118.     $output  = '<span class="checkbox '.$name."\">";

    1119. 

  1119.     $output .= '<input name="'.$name.'" id="'.$htmlid.'" type="checkbox" value="'.$value.'" alt="'.$alt.'"'.$strchecked.' '.((!empty($script)) ? ' onclick="'.$script.'" ' : '').' />';

    1120. 

  1120.     if(!empty($label)) {

    1121. 

  1121.         $output .= ' <label for="'.$htmlid.'">'.$label.'</label>';

    1122. 

  1122.     }

    1123. 

  1123.     $output .= '</span>'."\n";

    1124. 

  1124. 

    1125. 

  1125.     if (empty($return)) {

    1126. 

  1126.         echo $output;

    1127. 

  1127.     } else {

    1128. 

  1128.         return $output;

    1129. 

  1129.     }

    1130. 

  1130. 

    1131. 

  1131. }

    1132. 

  1132. 

    1133. 

  1133. /** Display an standard html text field with an optional label

    1134. 

  1134.  *

    1135. 

  1135.  * @param string  $name    The name of the text field

    1136. 

  1136.  * @param string  $value   The value of the text field

    1137. 

  1137.  * @param string  $label   The label to be showed near the text field

    1138. 

  1138.  * @param string  $alt     The info to be inserted in the alt tag

    1139. 

  1139.  */

    1140. 

  1140. function print_textfield ($name, $value, $alt = '',$size=50,$maxlength=0, $return=false) {

    1141. 

  1141. 

    1142. 

  1142.     static $idcounter = 0;

    1143. 

  1143. 

    1144. 

  1144.     if (empty($name)) {

    1145. 

  1145.         $name = 'unnamed';

    1146. 

  1146.     }

    1147. 

  1147. 

    1148. 

  1148.     if (empty($alt)) {

    1149. 

  1149.         $alt = 'textfield';

    1150. 

  1150.     }

    1151. 

  1151. 

    1152. 

  1152.     if (!empty($maxlength)) {

    1153. 

  1153.         $maxlength = ' maxlength="'.$maxlength.'" ';

    1154. 

  1154.     }

    1155. 

  1155. 

    1156. 

  1156.     $htmlid = 'auto-tf'.sprintf('%04d', ++$idcounter);

    1157. 

  1157.     $output  = '<span class="textfield '.$name."\">";

    1158. 

  1158.     $output .= '<input name="'.$name.'" id="'.$htmlid.'" type="text" value="'.$value.'" size="'.$size.'" '.$maxlength.' alt="'.$alt.'" />';

    1159. 

  1159. 

    1160. 

  1160.     $output .= '</span>'."\n";

    1161. 

  1161. 

    1162. 

  1162.     if (empty($return)) {

    1163. 

  1163.         echo $output;

    1164. 

  1164.     } else {

    1165. 

  1165.         return $output;

    1166. 

  1166.     }

    1167. 

  1167. 

    1168. 

  1168. }

    1169. 

  1169. 

    1170. 

  1170. 

    1171. 

  1171. /**

    1172. 

  1172.  * Implements a complete little popup form

    1173. 

  1173.  *

    1174. 

  1174.  * @uses $CFG

    1175. 

  1175.  * @param string $common  The URL up to the point of the variable that changes

    1176. 

  1176.  * @param array $options  Alist of value-label pairs for the popup list

    1177. 

  1177.  * @param string $formid Id must be unique on the page (originaly $formname)

    1178. 

  1178.  * @param string $selected The option that is already selected

    1179. 

  1179.  * @param string $nothing The label for the "no choice" option

    1180. 

  1180.  * @param string $help The name of a help page if help is required

    1181. 

  1181.  * @param string $helptext The name of the label for the help button

    1182. 

  1182.  * @param boolean $return Indicates whether the function should return the text

    1183. 

  1183.  *         as a string or echo it directly to the page being rendered

    1184. 

  1184.  * @param string $targetwindow The name of the target page to open the linked page in.

    1185. 

  1185.  * @param string $selectlabel Text to place in a [label] element - preferred for accessibility.

    1186. 

  1186.  * @param array $optionsextra TODO, an array?

    1187. 

  1187.  * @param mixed $gobutton If set, this turns off the JavaScript and uses a 'go'

    1188. 

  1188.  *   button instead (as is always included for JS-disabled users). Set to true

    1189. 

  1189.  *   for a literal 'Go' button, or to a string to change the name of the button.

    1190. 

  1190.  * @return string If $return is true then the entire form is returned as a string.

    1191. 

  1191.  * @todo Finish documenting this function<br>

    1192. 

  1192.  */

    1193. 

  1193. function popup_form($common, $options, $formid, $selected='', $nothing='choose', $help='', $helptext='', $return=false,

    1194. 

  1194. $targetwindow='self', $selectlabel='', $optionsextra=NULL, $gobutton=NULL) {

    1195. 

  1195. 

    1196. 

  1196.     global $CFG;

    1197. 

  1197.     static $go, $choose;   /// Locally cached, in case there's lots on a page

    1198. 

  1198. 

    1199. 

  1199.     if (empty($options)) {

    1200. 

  1200.         return '';

    1201. 

  1201.     }

    1202. 

  1202. 

    1203. 

  1203.     if (!isset($go)) {

    1204. 

  1204.         $go = get_string('go');

    1205. 

  1205.     }

    1206. 

  1206. 

    1207. 

  1207.     if ($nothing == 'choose') {

    1208. 

  1208.         if (!isset($choose)) {

    1209. 

  1209.             $choose = get_string('choose');

    1210. 

  1210.         }

    1211. 

  1211.         $nothing = $choose.'...';

    1212. 

  1212.     }

    1213. 

  1213. 

    1214. 

  1214.     // changed reference to document.getElementById('id_abc') instead of document.abc

    1215. 

  1215.     // MDL-7861

    1216. 

  1216.     $output = '<form action="'.$CFG->wwwroot.'/course/jumpto.php"'.

    1217. 

  1217.                         ' method="get" '.

    1218. 

  1218.                          $CFG->frametarget.

    1219. 

  1219.                         ' id="'.$formid.'"'.

    1220. 

  1220.                         ' class="popupform">';

    1221. 

  1221.     if ($help) {

    1222. 

  1222.         $button = helpbutton($help, $helptext, 'moodle', true, false, '', true);

    1223. 

  1223.     } else {

    1224. 

  1224.         $button = '';

    1225. 

  1225.     }

    1226. 

  1226. 

    1227. 

  1227.     if ($selectlabel) {

    1228. 

  1228.         $selectlabel = '<label for="'.$formid.'_jump">'.$selectlabel.'</label>';

    1229. 

  1229.     }

    1230. 

  1230. 

    1231. 

  1231.     if ($gobutton) {

    1232. 

  1232.         // Using the no-JavaScript version

    1233. 

  1233.         $javascript = '';

    1234. 

  1234.     } else if (check_browser_version('MSIE') || (check_browser_version('Opera') && !check_browser_operating_system("Linux"))) {

    1235. 

  1235.         //IE and Opera fire the onchange when ever you move into a dropdown list with the keyboard.

    1236. 

  1236.         //onfocus will call a function inside dropdown.js. It fixes this IE/Opera behavior.

    1237. 

  1237.         //Note: There is a bug on Opera+Linux with the javascript code (first mouse selection is inactive),

    1238. 

  1238.         //so we do not fix the Opera behavior on Linux

    1239. 

  1239.         $javascript = ' onfocus="initSelect(\''.$formid.'\','.$targetwindow.')"';

    1240. 

  1240.     } else {

    1241. 

  1241.         //Other browser

    1242. 

  1242.         $javascript = ' onchange="'.$targetwindow.

    1243. 

  1243.           '.location=document.getElementById(\''.$formid.

    1244. 

  1244.           '\').jump.options[document.getElementById(\''.

    1245. 

  1245.           $formid.'\').jump.selectedIndex].value;"';

    1246. 

  1246.     }

    1247. 

  1247. 

    1248. 

  1248.     $output .= '<div>'.$selectlabel.$button.'<select id="'.$formid.'_jump" name="jump"'.$javascript.'>'."\n";

    1249. 

  1249. 

    1250. 

  1250.     if ($nothing != '') {

    1251. 

  1251.         $output .= "   <option value=\"javascript:void(0)\">$nothing</option>\n";

    1252. 

  1252.     }

    1253. 

  1253. 

    1254. 

  1254.     $inoptgroup = false;

    1255. 

  1255. 

    1256. 

  1256.     foreach ($options as $value => $label) {

    1257. 

  1257. 

    1258. 

  1258.         if ($label == '--') { /// we are ending previous optgroup

    1259. 

  1259.             /// Check to see if we already have a valid open optgroup

    1260. 

  1260.             /// XHTML demands that there be at least 1 option within an optgroup

    1261. 

  1261.             if ($inoptgroup and (count($optgr) > 1) ) {

    1262. 

  1262.                 $output .= implode('', $optgr);

    1263. 

  1263.                 $output .= '   </optgroup>';

    1264. 

  1264.             }

    1265. 

  1265.             $optgr = array();

    1266. 

  1266.             $inoptgroup = false;

    1267. 

  1267.             continue;

    1268. 

  1268.         } else if (substr($label,0,2) == '--') { /// we are starting a new optgroup

    1269. 

  1269. 

    1270. 

  1270.             /// Check to see if we already have a valid open optgroup

    1271. 

  1271.             /// XHTML demands that there be at least 1 option within an optgroup

    1272. 

  1272.             if ($inoptgroup and (count($optgr) > 1) ) {

    1273. 

  1273.                 $output .= implode('', $optgr);

    1274. 

  1274.                 $output .= '   </optgroup>';

    1275. 

  1275.             }

    1276. 

  1276. 

    1277. 

  1277.             unset($optgr);

    1278. 

  1278.             $optgr = array();

    1279. 

  1279. 

    1280. 

  1280.             $optgr[]  = '   <optgroup label="'. s(format_string(substr($label,2))) .'">';   // Plain labels

    1281. 

  1281. 

    1282. 

  1282.             $inoptgroup = true; /// everything following will be in an optgroup

    1283. 

  1283.             continue;

    1284. 

  1284. 

    1285. 

  1285.         } else {

    1286. 

  1286.            if (!empty($CFG->usesid) && !isset($_COOKIE[session_name()]))

    1287. 

  1287.             {

    1288. 

  1288.                 $url=sid_process_url( $common . $value );

    1289. 

  1289.             } else

    1290. 

  1290.             {

    1291. 

  1291.                 $url=$common . $value;

    1292. 

  1292.             }

    1293. 

  1293.             $optstr = '   <option value="' . $url . '"';

    1294. 

  1294. 

    1295. 

  1295.             if ($value == $selected) {

    1296. 

  1296.                 $optstr .= ' selected="selected"';

    1297. 

  1297.             }

    1298. 

  1298. 

    1299. 

  1299.             if (!empty($optionsextra[$value])) {

    1300. 

  1300.                 $optstr .= ' '.$optionsextra[$value];

    1301. 

  1301.             }

    1302. 

  1302. 

    1303. 

  1303.             if ($label) {

    1304. 

  1304.                 $optstr .= '>'. $label .'</option>' . "\n";

    1305. 

  1305.             } else {

    1306. 

  1306.                 $optstr .= '>'. $value .'</option>' . "\n";

    1307. 

  1307.             }

    1308. 

  1308. 

    1309. 

  1309.             if ($inoptgroup) {

    1310. 

  1310.                 $optgr[] = $optstr;

    1311. 

  1311.             } else {

    1312. 

  1312.                 $output .= $optstr;

    1313. 

  1313.             }

    1314. 

  1314.         }

    1315. 

  1315. 

    1316. 

  1316.     }

    1317. 

  1317. 

    1318. 

  1318.     /// catch the final group if not closed

    1319. 

  1319.     if ($inoptgroup and count($optgr) > 1) {

    1320. 

  1320.         $output .= implode('', $optgr);

    1321. 

  1321.         $output .= '    </optgroup>';

    1322. 

  1322.     }

    1323. 

  1323. 

    1324. 

  1324.     $output .= '</select>';

    1325. 

  1325.     $output .= '<input type="hidden" name="sesskey" value="'.sesskey().'" />';

    1326. 

  1326.     if ($gobutton) {

    1327. 

  1327.         $output .= '<input type="submit" value="'.

    1328. 

  1328.             ($gobutton===true ? $go : $gobutton).'" />';

    1329. 

  1329.     } else {

    1330. 

  1330.         $output .= '<div id="noscript'.$formid.'" style="display: inline;">';

    1331. 

  1331.         $output .= '<input type="submit" value="'.$go.'" /></div>';

    1332. 

  1332.         $output .= '<script type="text/javascript">'.

    1333. 

  1333.                    "\n//<![CDATA[\n".

    1334. 

  1334.                    'document.getElementById("noscript'.$formid.'").style.display = "none";'.

    1335. 

  1335.                    "\n//]]>\n".'</script>';

    1336. 

  1336.     }

    1337. 

  1337.     $output .= '</div></form>';

    1338. 

  1338. 

    1339. 

  1339.     if ($return) {

    1340. 

  1340.         return $output;

    1341. 

  1341.     } else {

    1342. 

  1342.         echo $output;

    1343. 

  1343.     }

    1344. 

  1344. }

    1345. 

  1345. 

    1346. 

  1346. 

    1347. 

  1347. /**

    1348. 

  1348.  * Prints some red text

    1349. 

  1349.  *

    1350. 

  1350.  * @param string $error The text to be displayed in red

    1351. 

  1351.  */

    1352. 

  1352. function formerr($error) {

    1353. 

  1353. 

    1354. 

  1354.     if (!empty($error)) {

    1355. 

  1355.         echo '<span class="error">'. $error .'</span>';

    1356. 

  1356.     }

    1357. 

  1357. }

    1358. 

  1358. 

    1359. 

  1359. /**

    1360. 

  1360.  * Validates an email to make sure it makes sense.

    1361. 

  1361.  *

    1362. 

  1362.  * @param string $address The email address to validate.

    1363. 

  1363.  * @return boolean

    1364. 

  1364.  */

    1365. 

  1365. function validate_email($address) {

    1366. 

  1366. 

    1367. 

  1367.     return (ereg('^[-!#$%&\'*+\\/0-9=?A-Z^_`a-z{|}~]+'.

    1368. 

  1368.                  '(\.[-!#$%&\'*+\\/0-9=?A-Z^_`a-z{|}~]+)*'.

    1369. 

  1369.                   '@'.

    1370. 

  1370.                   '[-!#$%&\'*+\\/0-9=?A-Z^_`a-z{|}~]+\.'.

    1371. 

  1371.                   '[-!#$%&\'*+\\./0-9=?A-Z^_`a-z{|}~]+$',

    1372. 

  1372.                   $address));

    1373. 

  1373. }

    1374. 

  1374. 

    1375. 

  1375. /**

    1376. 

  1376.  * Extracts file argument either from file parameter or PATH_INFO

    1377. 

  1377.  *

    1378. 

  1378.  * @param string $scriptname name of the calling script

    1379. 

  1379.  * @return string file path (only safe characters)

    1380. 

  1380.  */

    1381. 

  1381. function get_file_argument($scriptname) {

    1382. 

  1382.     global $_SERVER;
…
    1383.

Large files files are truncated, but you can click here to view the full file