4281232a8545700f3ed5502f131600cb937c2f84
[moodle.git] / lib / tablelib.php
1 <?php
3 // This file is part of Moodle - http://moodle.org/
4 //
5 // Moodle is free software: you can redistribute it and/or modify
6 // it under the terms of the GNU General Public License as published by
7 // the Free Software Foundation, either version 3 of the License, or
8 // (at your option) any later version.
9 //
10 // Moodle is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
18 /**
19  * @package    core
20  * @subpackage lib
21  * @copyright  1999 onwards Martin Dougiamas  {@link http://moodle.com}
22  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
23  */
26 defined('MOODLE_INTERNAL') || die();
28 /**#@+
29  * These constants relate to the table's handling of URL parameters.
30  */
31 define('TABLE_VAR_SORT',   1);
32 define('TABLE_VAR_HIDE',   2);
33 define('TABLE_VAR_SHOW',   3);
34 define('TABLE_VAR_IFIRST', 4);
35 define('TABLE_VAR_ILAST',  5);
36 define('TABLE_VAR_PAGE',   6);
37 /**#@-*/
39 /**#@+
40  * Constants that indicate whether the paging bar for the table
41  * appears above or below the table.
42  */
43 define('TABLE_P_TOP',    1);
44 define('TABLE_P_BOTTOM', 2);
45 /**#@-*/
48 /**
49  * @package   moodlecore
50  * @copyright 1999 onwards Martin Dougiamas  {@link http://moodle.com}
51  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
52  */
53 class flexible_table {
55     var $uniqueid        = NULL;
56     var $attributes      = array();
57     var $headers         = array();
58     var $columns         = array();
59     var $column_style    = array();
60     var $column_class    = array();
61     var $column_suppress = array();
62     var $column_nosort   = array('userpic');
63     var $setup           = false;
64     var $sess            = NULL;
65     var $baseurl         = NULL;
66     var $request         = array();
68     var $is_collapsible = false;
69     var $is_sortable    = false;
70     var $use_pages      = false;
71     var $use_initials   = false;
73     var $maxsortkeys = 2;
74     var $pagesize    = 30;
75     var $currpage    = 0;
76     var $totalrows   = 0;
77     var $sort_default_column = NULL;
78     var $sort_default_order  = SORT_ASC;
80     /**
81      * Array of positions in which to display download controls.
82      */
83     var $showdownloadbuttonsat= array(TABLE_P_TOP);
85     /**
86      * @var string Key of field returned by db query that is the id field of the
87      * user table or equivalent.
88      */
89     public $useridfield = 'id';
91     /**
92      * @var string which download plugin to use. Default '' means none - print
93      * html table with paging. Property set by is_downloading which typically
94      * passes in cleaned data from $
95      */
96     var $download  = '';
98     /**
99      * @var bool whether data is downloadable from table. Determines whether
100      * to display download buttons. Set by method downloadable().
101      */
102     var $downloadable = false;
104     /**
105      * @var string which download plugin to use. Default '' means none - print
106      * html table with paging.
107      */
108     var $defaultdownloadformat  = 'csv';
110     /**
111      * @var bool Has start output been called yet?
112      */
113     var $started_output = false;
115     var $exportclass = null;
117     /**
118      * Constructor
119      * @param int $uniqueid all tables have to have a unique id, this is used
120      *      as a key when storing table properties like sort order in the session.
121      */
122     function __construct($uniqueid) {
123         $this->uniqueid = $uniqueid;
124         $this->request  = array(
125             TABLE_VAR_SORT   => 'tsort',
126             TABLE_VAR_HIDE   => 'thide',
127             TABLE_VAR_SHOW   => 'tshow',
128             TABLE_VAR_IFIRST => 'tifirst',
129             TABLE_VAR_ILAST  => 'tilast',
130             TABLE_VAR_PAGE   => 'page',
131         );
132     }
134     /**
135      * Call this to pass the download type. Use :
136      *         $download = optional_param('download', '', PARAM_ALPHA);
137      * To get the download type. We assume that if you call this function with
138      * params that this table's data is downloadable, so we call is_downloadable
139      * for you (even if the param is '', which means no download this time.
140      * Also you can call this method with no params to get the current set
141      * download type.
142      * @param string $download download type. One of csv, tsv, xhtml, ods, etc
143      * @param string $filename filename for downloads without file extension.
144      * @param string $sheettitle title for downloaded data.
145      * @return string download type.  One of csv, tsv, xhtml, ods, etc
146      */
147     function is_downloading($download = null, $filename='', $sheettitle='') {
148         if ($download!==null) {
149             $this->sheettitle = $sheettitle;
150             $this->is_downloadable(true);
151             $this->download = $download;
152             $this->filename = clean_filename($filename);
153             $this->export_class_instance();
154         }
155         return $this->download;
156     }
158     /**
159      * Get, and optionally set, the export class.
160      * @param $exportclass (optional) if passed, set the table to use this export class.
161      * @return table_default_export_format_parent the export class in use (after any set).
162      */
163     function export_class_instance($exportclass = null) {
164         if (!is_null($exportclass)) {
165             $this->started_output = true;
166             $this->exportclass = $exportclass;
167             $this->exportclass->table = $this;
168         } else if (is_null($this->exportclass) && !empty($this->download)) {
169             $classname = 'table_'.$this->download.'_export_format';
170             $this->exportclass = new $classname($this);
171             if (!$this->exportclass->document_started()) {
172                 $this->exportclass->start_document($this->filename);
173             }
174         }
175         return $this->exportclass;
176     }
178     /**
179      * Probably don't need to call this directly. Calling is_downloading with a
180      * param automatically sets table as downloadable.
181      *
182      * @param bool $downloadable optional param to set whether data from
183      * table is downloadable. If ommitted this function can be used to get
184      * current state of table.
185      * @return bool whether table data is set to be downloadable.
186      */
187     function is_downloadable($downloadable = null) {
188         if ($downloadable !== null) {
189             $this->downloadable = $downloadable;
190         }
191         return $this->downloadable;
192     }
194     /**
195      * Where to show download buttons.
196      * @param array $showat array of postions in which to show download buttons.
197      * Containing TABLE_P_TOP and/or TABLE_P_BOTTOM
198      */
199     function show_download_buttons_at($showat) {
200         $this->showdownloadbuttonsat = $showat;
201     }
203     /**
204      * Sets the is_sortable variable to the given boolean, sort_default_column to
205      * the given string, and the sort_default_order to the given integer.
206      * @param bool $bool
207      * @param string $defaultcolumn
208      * @param int $defaultorder
209      * @return void
210      */
211     function sortable($bool, $defaultcolumn = NULL, $defaultorder = SORT_ASC) {
212         $this->is_sortable = $bool;
213         $this->sort_default_column = $defaultcolumn;
214         $this->sort_default_order  = $defaultorder;
215     }
217     /**
218      * Do not sort using this column
219      * @param string column name
220      */
221     function no_sorting($column) {
222         $this->column_nosort[] = $column;
223     }
225     /**
226      * Is the column sortable?
227      * @param string column name, null means table
228      * @return bool
229      */
230     function is_sortable($column = null) {
231         if (empty($column)) {
232             return $this->is_sortable;
233         }
234         if (!$this->is_sortable) {
235             return false;
236         }
237         return !in_array($column, $this->column_nosort);
238     }
240     /**
241      * Sets the is_collapsible variable to the given boolean.
242      * @param bool $bool
243      * @return void
244      */
245     function collapsible($bool) {
246         $this->is_collapsible = $bool;
247     }
249     /**
250      * Sets the use_pages variable to the given boolean.
251      * @param bool $bool
252      * @return void
253      */
254     function pageable($bool) {
255         $this->use_pages = $bool;
256     }
258     /**
259      * Sets the use_initials variable to the given boolean.
260      * @param bool $bool
261      * @return void
262      */
263     function initialbars($bool) {
264         $this->use_initials = $bool;
265     }
267     /**
268      * Sets the pagesize variable to the given integer, the totalrows variable
269      * to the given integer, and the use_pages variable to true.
270      * @param int $perpage
271      * @param int $total
272      * @return void
273      */
274     function pagesize($perpage, $total) {
275         $this->pagesize  = $perpage;
276         $this->totalrows = $total;
277         $this->use_pages = true;
278     }
280     /**
281      * Assigns each given variable in the array to the corresponding index
282      * in the request class variable.
283      * @param array $variables
284      * @return void
285      */
286     function set_control_variables($variables) {
287         foreach ($variables as $what => $variable) {
288             if (isset($this->request[$what])) {
289                 $this->request[$what] = $variable;
290             }
291         }
292     }
294     /**
295      * Gives the given $value to the $attribute index of $this->attributes.
296      * @param string $attribute
297      * @param mixed $value
298      * @return void
299      */
300     function set_attribute($attribute, $value) {
301         $this->attributes[$attribute] = $value;
302     }
304     /**
305      * What this method does is set the column so that if the same data appears in
306      * consecutive rows, then it is not repeated.
307      *
308      * For example, in the quiz overview report, the fullname column is set to be suppressed, so
309      * that when one student has made multiple attempts, their name is only printed in the row
310      * for their first attempt.
311      * @param int $column the index of a column.
312      */
313     function column_suppress($column) {
314         if (isset($this->column_suppress[$column])) {
315             $this->column_suppress[$column] = true;
316         }
317     }
319     /**
320      * Sets the given $column index to the given $classname in $this->column_class.
321      * @param int $column
322      * @param string $classname
323      * @return void
324      */
325     function column_class($column, $classname) {
326         if (isset($this->column_class[$column])) {
327             $this->column_class[$column] = ' '.$classname; // This space needed so that classnames don't run together in the HTML
328         }
329     }
331     /**
332      * Sets the given $column index and $property index to the given $value in $this->column_style.
333      * @param int $column
334      * @param string $property
335      * @param mixed $value
336      * @return void
337      */
338     function column_style($column, $property, $value) {
339         if (isset($this->column_style[$column])) {
340             $this->column_style[$column][$property] = $value;
341         }
342     }
344     /**
345      * Sets all columns' $propertys to the given $value in $this->column_style.
346      * @param int $property
347      * @param string $value
348      * @return void
349      */
350     function column_style_all($property, $value) {
351         foreach (array_keys($this->columns) as $column) {
352             $this->column_style[$column][$property] = $value;
353         }
354     }
356     /**
357      * Sets $this->baseurl.
358      * @param moodle_url|string $url the url with params needed to call up this page
359      */
360     function define_baseurl($url) {
361         $this->baseurl = new moodle_url($url);
362     }
364     /**
365      * @param array $columns an array of identifying names for columns. If
366      * columns are sorted then column names must correspond to a field in sql.
367      */
368     function define_columns($columns) {
369         $this->columns = array();
370         $this->column_style = array();
371         $this->column_class = array();
372         $colnum = 0;
374         foreach ($columns as $column) {
375             $this->columns[$column]         = $colnum++;
376             $this->column_style[$column]    = array();
377             $this->column_class[$column]    = '';
378             $this->column_suppress[$column] = false;
379         }
380     }
382     /**
383      * @param array $headers numerical keyed array of displayed string titles
384      * for each column.
385      */
386     function define_headers($headers) {
387         $this->headers = $headers;
388     }
390     /**
391      * Must be called after table is defined. Use methods above first. Cannot
392      * use functions below till after calling this method.
393      * @return type?
394      */
395     function setup() {
396         global $SESSION, $CFG;
398         if (empty($this->columns) || empty($this->uniqueid)) {
399             return false;
400         }
402         if (!isset($SESSION->flextable)) {
403             $SESSION->flextable = array();
404         }
406         if (!isset($SESSION->flextable[$this->uniqueid])) {
407             $SESSION->flextable[$this->uniqueid] = new stdClass;
408             $SESSION->flextable[$this->uniqueid]->uniqueid = $this->uniqueid;
409             $SESSION->flextable[$this->uniqueid]->collapse = array();
410             $SESSION->flextable[$this->uniqueid]->sortby   = array();
411             $SESSION->flextable[$this->uniqueid]->i_first  = '';
412             $SESSION->flextable[$this->uniqueid]->i_last   = '';
413         }
415         $this->sess = &$SESSION->flextable[$this->uniqueid];
417         if (($showcol = optional_param($this->request[TABLE_VAR_SHOW], '', PARAM_ALPHANUMEXT)) &&
418                 isset($this->columns[$showcol])) {
419             $this->sess->collapse[$showcol] = false;
421         } else if (($hidecol = optional_param($this->request[TABLE_VAR_HIDE], '', PARAM_ALPHANUMEXT)) &&
422                 isset($this->columns[$hidecol])) {
423             $this->sess->collapse[$hidecol] = true;
424             if (array_key_exists($hidecol, $this->sess->sortby)) {
425                 unset($this->sess->sortby[$hidecol]);
426             }
427         }
429         // Now, update the column attributes for collapsed columns
430         foreach (array_keys($this->columns) as $column) {
431             if (!empty($this->sess->collapse[$column])) {
432                 $this->column_style[$column]['width'] = '10px';
433             }
434         }
436         if (($sortcol = optional_param($this->request[TABLE_VAR_SORT], '', PARAM_ALPHANUMEXT)) &&
437                 $this->is_sortable($sortcol) && empty($this->sess->collapse[$sortcol]) &&
438                 (isset($this->columns[$sortcol]) || in_array($sortcol, array('firstname', 'lastname')) && isset($this->columns['fullname']))) {
440             if (array_key_exists($sortcol, $this->sess->sortby)) {
441                 // This key already exists somewhere. Change its sortorder and bring it to the top.
442                 $sortorder = $this->sess->sortby[$sortcol] == SORT_ASC ? SORT_DESC : SORT_ASC;
443                 unset($this->sess->sortby[$sortcol]);
444                 $this->sess->sortby = array_merge(array($sortcol => $sortorder), $this->sess->sortby);
445             } else {
446                 // Key doesn't exist, so just add it to the beginning of the array, ascending order
447                 $this->sess->sortby = array_merge(array($sortcol => SORT_ASC), $this->sess->sortby);
448             }
450             // Finally, make sure that no more than $this->maxsortkeys are present into the array
451             $this->sess->sortby = array_slice($this->sess->sortby, 0, $this->maxsortkeys);
452         }
454         // MDL-35375 - If a default order is defined and it is not in the current list of order by columns, add it at the end.
455         // This prevents results from being returned in a random order if the only order by column contains equal values.
456         if (!empty($this->sort_default_column))  {
457             if (!array_key_exists($this->sort_default_column, $this->sess->sortby)) {
458                 $defaultsort = array($this->sort_default_column => $this->sort_default_order);
459                 $this->sess->sortby = array_merge($this->sess->sortby, $defaultsort);
460             }
461         }
463         $ilast = optional_param($this->request[TABLE_VAR_ILAST], null, PARAM_RAW);
464         if (!is_null($ilast) && ($ilast ==='' || strpos(get_string('alphabet', 'langconfig'), $ilast) !== false)) {
465             $this->sess->i_last = $ilast;
466         }
468         $ifirst = optional_param($this->request[TABLE_VAR_IFIRST], null, PARAM_RAW);
469         if (!is_null($ifirst) && ($ifirst === '' || strpos(get_string('alphabet', 'langconfig'), $ifirst) !== false)) {
470             $this->sess->i_first = $ifirst;
471         }
473         if (empty($this->baseurl)) {
474             debugging('You should set baseurl when using flexible_table.');
475             global $PAGE;
476             $this->baseurl = $PAGE->url;
477         }
479         $this->currpage = optional_param($this->request[TABLE_VAR_PAGE], 0, PARAM_INT);
480         $this->setup = true;
482         // Always introduce the "flexible" class for the table if not specified
483         if (empty($this->attributes)) {
484             $this->attributes['class'] = 'flexible';
485         } else if (!isset($this->attributes['class'])) {
486             $this->attributes['class'] = 'flexible';
487         } else if (!in_array('flexible', explode(' ', $this->attributes['class']))) {
488             $this->attributes['class'] = trim('flexible ' . $this->attributes['class']);
489         }
490     }
492     /**
493      * Get the order by clause from the session, for the table with id $uniqueid.
494      * @param string $uniqueid the identifier for a table.
495      * @return SQL fragment that can be used in an ORDER BY clause.
496      */
497     public static function get_sort_for_table($uniqueid) {
498         global $SESSION;
499         if (empty($SESSION->flextable[$uniqueid])) {
500            return '';
501         }
503         $sess = &$SESSION->flextable[$uniqueid];
504         if (empty($sess->sortby)) {
505             return '';
506         }
508         return self::construct_order_by($sess->sortby);
509     }
511     /**
512      * Prepare an an order by clause from the list of columns to be sorted.
513      * @param array $cols column name => SORT_ASC or SORT_DESC
514      * @return SQL fragment that can be used in an ORDER BY clause.
515      */
516     public static function construct_order_by($cols) {
517         $bits = array();
519         foreach ($cols as $column => $order) {
520             if ($order == SORT_ASC) {
521                 $bits[] = $column . ' ASC';
522             } else {
523                 $bits[] = $column . ' DESC';
524             }
525         }
527         return implode(', ', $bits);
528     }
530     /**
531      * @return SQL fragment that can be used in an ORDER BY clause.
532      */
533     public function get_sql_sort() {
534         return self::construct_order_by($this->get_sort_columns());
535     }
537     /**
538      * Get the columns to sort by, in the form required by {@link construct_order_by()}.
539      * @return array column name => SORT_... constant.
540      */
541     public function get_sort_columns() {
542         if (!$this->setup) {
543             throw new coding_exception('Cannot call get_sort_columns until you have called setup.');
544         }
546         if (empty($this->sess->sortby)) {
547             return array();
548         }
550         foreach ($this->sess->sortby as $column => $notused) {
551             if (isset($this->columns[$column])) {
552                 continue; // This column is OK.
553             }
554             if (in_array($column, array('firstname', 'lastname')) &&
555                     isset($this->columns['fullname'])) {
556                 continue; // This column is OK.
557             }
558             // This column is not OK.
559             unset($this->sess->sortby[$column]);
560         }
562         return $this->sess->sortby;
563     }
565     /**
566      * @return int the offset for LIMIT clause of SQL
567      */
568     function get_page_start() {
569         if (!$this->use_pages) {
570             return '';
571         }
572         return $this->currpage * $this->pagesize;
573     }
575     /**
576      * @return int the pagesize for LIMIT clause of SQL
577      */
578     function get_page_size() {
579         if (!$this->use_pages) {
580             return '';
581         }
582         return $this->pagesize;
583     }
585     /**
586      * @return string sql to add to where statement.
587      */
588     function get_sql_where() {
589         global $DB;
591         $conditions = array();
592         $params = array();
594         if (isset($this->columns['fullname'])) {
595             static $i = 0;
596             $i++;
598             if (!empty($this->sess->i_first)) {
599                 $conditions[] = $DB->sql_like('firstname', ':ifirstc'.$i, false, false);
600                 $params['ifirstc'.$i] = $this->sess->i_first.'%';
601             }
602             if (!empty($this->sess->i_last)) {
603                 $conditions[] = $DB->sql_like('lastname', ':ilastc'.$i, false, false);
604                 $params['ilastc'.$i] = $this->sess->i_last.'%';
605             }
606         }
608         return array(implode(" AND ", $conditions), $params);
609     }
611     /**
612      * Add a row of data to the table. This function takes an array with
613      * column names as keys.
614      * It ignores any elements with keys that are not defined as columns. It
615      * puts in empty strings into the row when there is no element in the passed
616      * array corresponding to a column in the table. It puts the row elements in
617      * the proper order.
618      * @param $rowwithkeys array
619      * @param string $classname CSS class name to add to this row's tr tag.
620      */
621     function add_data_keyed($rowwithkeys, $classname = '') {
622         $this->add_data($this->get_row_from_keyed($rowwithkeys), $classname);
623     }
625     /**
626      * Add a seperator line to table.
627      */
628     function add_separator() {
629         if (!$this->setup) {
630             return false;
631         }
632         $this->add_data(NULL);
633     }
635     /**
636      * This method actually directly echoes the row passed to it now or adds it
637      * to the download. If this is the first row and start_output has not
638      * already been called this method also calls start_output to open the table
639      * or send headers for the downloaded.
640      * Can be used as before. print_html now calls finish_html to close table.
641      *
642      * @param array $row a numerically keyed row of data to add to the table.
643      * @param string $classname CSS class name to add to this row's tr tag.
644      * @return bool success.
645      */
646     function add_data($row, $classname = '') {
647         if (!$this->setup) {
648             return false;
649         }
650         if (!$this->started_output) {
651             $this->start_output();
652         }
653         if ($this->exportclass!==null) {
654             if ($row === null) {
655                 $this->exportclass->add_seperator();
656             } else {
657                 $this->exportclass->add_data($row);
658             }
659         } else {
660             $this->print_row($row, $classname);
661         }
662         return true;
663     }
665     /**
666      * You should call this to finish outputting the table data after adding
667      * data to the table with add_data or add_data_keyed.
668      *
669      */
670     function finish_output($closeexportclassdoc = true) {
671         if ($this->exportclass!==null) {
672             $this->exportclass->finish_table();
673             if ($closeexportclassdoc) {
674                 $this->exportclass->finish_document();
675             }
676         } else {
677             $this->finish_html();
678         }
679     }
681     /**
682      * Hook that can be overridden in child classes to wrap a table in a form
683      * for example. Called only when there is data to display and not
684      * downloading.
685      */
686     function wrap_html_start() {
687     }
689     /**
690      * Hook that can be overridden in child classes to wrap a table in a form
691      * for example. Called only when there is data to display and not
692      * downloading.
693      */
694     function wrap_html_finish() {
695     }
697     /**
698      *
699      * @param array $row row of data from db used to make one row of the table.
700      * @return array one row for the table, added using add_data_keyed method.
701      */
702     function format_row($row) {
703         $formattedrow = array();
704         foreach (array_keys($this->columns) as $column) {
705             $colmethodname = 'col_'.$column;
706             if (method_exists($this, $colmethodname)) {
707                 $formattedcolumn = $this->$colmethodname($row);
708             } else {
709                 $formattedcolumn = $this->other_cols($column, $row);
710                 if ($formattedcolumn===NULL) {
711                     $formattedcolumn = $row->$column;
712                 }
713             }
714             $formattedrow[$column] = $formattedcolumn;
715         }
716         return $formattedrow;
717     }
719     /**
720      * Fullname is treated as a special columname in tablelib and should always
721      * be treated the same as the fullname of a user.
722      * @uses $this->useridfield if the userid field is not expected to be id
723      * then you need to override $this->useridfield to point at the correct
724      * field for the user id.
725      *
726      */
727     function col_fullname($row) {
728         global $COURSE, $CFG;
730         $name = fullname($row);
731         if ($this->download) {
732             return $name;
733         }
735         $userid = $row->{$this->useridfield};
736         if ($COURSE->id == SITEID) {
737             $profileurl = new moodle_url('/user/profile.php', array('id' => $userid));
738         } else {
739             $profileurl = new moodle_url('/user/view.php',
740                     array('id' => $userid, 'course' => $COURSE->id));
741         }
742         return html_writer::link($profileurl, $name);
743     }
745     /**
746      * You can override this method in a child class. See the description of
747      * build_table which calls this method.
748      */
749     function other_cols($column, $row) {
750         return NULL;
751     }
753     /**
754      * Used from col_* functions when text is to be displayed. Does the
755      * right thing - either converts text to html or strips any html tags
756      * depending on if we are downloading and what is the download type. Params
757      * are the same as format_text function in weblib.php but some default
758      * options are changed.
759      */
760     function format_text($text, $format=FORMAT_MOODLE, $options=NULL, $courseid=NULL) {
761         if (!$this->is_downloading()) {
762             if (is_null($options)) {
763                 $options = new stdClass;
764             }
765             //some sensible defaults
766             if (!isset($options->para)) {
767                 $options->para = false;
768             }
769             if (!isset($options->newlines)) {
770                 $options->newlines = false;
771             }
772             if (!isset($options->smiley)) {
773                 $options->smiley = false;
774             }
775             if (!isset($options->filter)) {
776                 $options->filter = false;
777             }
778             return format_text($text, $format, $options);
779         } else {
780             $eci =& $this->export_class_instance();
781             return $eci->format_text($text, $format, $options, $courseid);
782         }
783     }
784     /**
785      * This method is deprecated although the old api is still supported.
786      * @deprecated 1.9.2 - Jun 2, 2008
787      */
788     function print_html() {
789         if (!$this->setup) {
790             return false;
791         }
792         $this->finish_html();
793     }
795     /**
796      * This function is not part of the public api.
797      * @return string initial of first name we are currently filtering by
798      */
799     function get_initial_first() {
800         if (!$this->use_initials) {
801             return NULL;
802         }
804         return $this->sess->i_first;
805     }
807     /**
808      * This function is not part of the public api.
809      * @return string initial of last name we are currently filtering by
810      */
811     function get_initial_last() {
812         if (!$this->use_initials) {
813             return NULL;
814         }
816         return $this->sess->i_last;
817     }
819     /**
820      * Helper function, used by {@link print_initials_bar()} to output one initial bar.
821      * @param array $alpha of letters in the alphabet.
822      * @param string $current the currently selected letter.
823      * @param string $class class name to add to this initial bar.
824      * @param string $title the name to put in front of this initial bar.
825      * @param string $urlvar URL parameter name for this initial.
826      */
827     protected function print_one_initials_bar($alpha, $current, $class, $title, $urlvar) {
828         echo html_writer::start_tag('div', array('class' => 'initialbar ' . $class)) .
829                 $title . ' : ';
830         if ($current) {
831             echo html_writer::link($this->baseurl->out(false, array($urlvar => '')), get_string('all'));
832         } else {
833             echo html_writer::tag('strong', get_string('all'));
834         }
836         foreach ($alpha as $letter) {
837             if ($letter === $current) {
838                 echo html_writer::tag('strong', $letter);
839             } else {
840                 echo html_writer::link($this->baseurl->out(false, array($urlvar => $letter)), $letter);
841             }
842         }
844         echo html_writer::end_tag('div');
845     }
847     /**
848      * This function is not part of the public api.
849      */
850     function print_initials_bar() {
851         if ((!empty($this->sess->i_last) || !empty($this->sess->i_first) ||$this->use_initials)
852                     && isset($this->columns['fullname'])) {
854             $alpha  = explode(',', get_string('alphabet', 'langconfig'));
856             // Bar of first initials
857             if (!empty($this->sess->i_first)) {
858                 $ifirst = $this->sess->i_first;
859             } else {
860                 $ifirst = '';
861             }
862             $this->print_one_initials_bar($alpha, $ifirst, 'firstinitial',
863                     get_string('firstname'), $this->request[TABLE_VAR_IFIRST]);
865             // Bar of last initials
866             if (!empty($this->sess->i_last)) {
867                 $ilast = $this->sess->i_last;
868             } else {
869                 $ilast = '';
870             }
871             $this->print_one_initials_bar($alpha, $ilast, 'lastinitial',
872                     get_string('lastname'), $this->request[TABLE_VAR_ILAST]);
873         }
874     }
876     /**
877      * This function is not part of the public api.
878      */
879     function print_nothing_to_display() {
880         global $OUTPUT;
881         $this->print_initials_bar();
883         echo $OUTPUT->heading(get_string('nothingtodisplay'));
884     }
886     /**
887      * This function is not part of the public api.
888      */
889     function get_row_from_keyed($rowwithkeys) {
890         if (is_object($rowwithkeys)) {
891             $rowwithkeys = (array)$rowwithkeys;
892         }
893         $row = array();
894         foreach (array_keys($this->columns) as $column) {
895             if (isset($rowwithkeys[$column])) {
896                 $row [] = $rowwithkeys[$column];
897             } else {
898                 $row[] ='';
899             }
900         }
901         return $row;
902     }
903     /**
904      * This function is not part of the public api.
905      */
906     function get_download_menu() {
907         $allclasses= get_declared_classes();
908         $exportclasses = array();
909         foreach ($allclasses as $class) {
910             $matches = array();
911             if (preg_match('/^table\_([a-z]+)\_export\_format$/', $class, $matches)) {
912                 $type = $matches[1];
913                 $exportclasses[$type]= get_string("download$type", 'table');
914             }
915         }
916         return $exportclasses;
917     }
919     /**
920      * This function is not part of the public api.
921      */
922     function download_buttons() {
923         if ($this->is_downloadable() && !$this->is_downloading()) {
924             $downloadoptions = $this->get_download_menu();
926             $downloadelements = new stdClass();
927             $downloadelements->formatsmenu = html_writer::select($downloadoptions,
928                     'download', $this->defaultdownloadformat, false);
929             $downloadelements->downloadbutton = '<input type="submit" value="'.
930                     get_string('download').'"/>';
931             $html = '<form action="'. $this->baseurl .'" method="post">';
932             $html .= '<div class="mdl-align">';
933             $html .= html_writer::tag('label', get_string('downloadas', 'table', $downloadelements));
934             $html .= '</div></form>';
936             return $html;
937         } else {
938             return '';
939         }
940     }
941     /**
942      * This function is not part of the public api.
943      * You don't normally need to call this. It is called automatically when
944      * needed when you start adding data to the table.
945      *
946      */
947     function start_output() {
948         $this->started_output = true;
949         if ($this->exportclass!==null) {
950             $this->exportclass->start_table($this->sheettitle);
951             $this->exportclass->output_headers($this->headers);
952         } else {
953             $this->start_html();
954             $this->print_headers();
955             echo html_writer::start_tag('tbody');
956         }
957     }
959     /**
960      * This function is not part of the public api.
961      */
962     function print_row($row, $classname = '') {
963         static $suppress_lastrow = NULL;
964         static $oddeven = 1;
965         $rowclasses = array('r' . $oddeven);
966         $oddeven = $oddeven ? 0 : 1;
968         if ($classname) {
969             $rowclasses[] = $classname;
970         }
972         echo html_writer::start_tag('tr', array('class' => implode(' ', $rowclasses)));
974         // If we have a separator, print it
975         if ($row === NULL) {
976             $colcount = count($this->columns);
977             echo html_writer::tag('td', html_writer::tag('div', '',
978                     array('class' => 'tabledivider')), array('colspan' => $colcount));
980         } else {
981             $colbyindex = array_flip($this->columns);
982             foreach ($row as $index => $data) {
983                 $column = $colbyindex[$index];
985                 if (empty($this->sess->collapse[$column])) {
986                     if ($this->column_suppress[$column] && $suppress_lastrow !== NULL && $suppress_lastrow[$index] === $data) {
987                         $content = '&nbsp;';
988                     } else {
989                         $content = $data;
990                     }
991                 } else {
992                     $content = '&nbsp;';
993                 }
995                 echo html_writer::tag('td', $content, array(
996                         'class' => 'cell c' . $index . $this->column_class[$column],
997                         'style' => $this->make_styles_string($this->column_style[$column])));
998             }
999         }
1001         echo html_writer::end_tag('tr');
1003         $suppress_enabled = array_sum($this->column_suppress);
1004         if ($suppress_enabled) {
1005             $suppress_lastrow = $row;
1006         }
1007     }
1009     /**
1010      * This function is not part of the public api.
1011      */
1012     function finish_html() {
1013         global $OUTPUT;
1014         if (!$this->started_output) {
1015             //no data has been added to the table.
1016             $this->print_nothing_to_display();
1018         } else {
1019             echo html_writer::end_tag('tbody');
1020             echo html_writer::end_tag('table');
1021             echo html_writer::end_tag('div');
1022             $this->wrap_html_finish();
1024             // Paging bar
1025             if(in_array(TABLE_P_BOTTOM, $this->showdownloadbuttonsat)) {
1026                 echo $this->download_buttons();
1027             }
1029             if($this->use_pages) {
1030                 $pagingbar = new paging_bar($this->totalrows, $this->currpage, $this->pagesize, $this->baseurl);
1031                 $pagingbar->pagevar = $this->request[TABLE_VAR_PAGE];
1032                 echo $OUTPUT->render($pagingbar);
1033             }
1034         }
1035     }
1037     /**
1038      * Generate the HTML for the collapse/uncollapse icon. This is a helper method
1039      * used by {@link print_headers()}.
1040      * @param string $column the column name, index into various names.
1041      * @param int $index numerical index of the column.
1042      * @return string HTML fragment.
1043      */
1044     protected function show_hide_link($column, $index) {
1045         global $OUTPUT;
1046         // Some headers contain <br /> tags, do not include in title, hence the
1047         // strip tags.
1049         if (!empty($this->sess->collapse[$column])) {
1050             return html_writer::link($this->baseurl->out(false, array($this->request[TABLE_VAR_SHOW] => $column)),
1051                     html_writer::empty_tag('img', array('src' => $OUTPUT->pix_url('t/switch_plus'), 'alt' => get_string('show'))),
1052                     array('title' => get_string('show') . ' ' . strip_tags($this->headers[$index])));
1054         } else if ($this->headers[$index] !== NULL) {
1055             return html_writer::link($this->baseurl->out(false, array($this->request[TABLE_VAR_HIDE] => $column)),
1056                     html_writer::empty_tag('img', array('src' => $OUTPUT->pix_url('t/switch_minus'), 'alt' => get_string('hide'))),
1057                     array('title' => get_string('hide') . ' ' . strip_tags($this->headers[$index])));
1058         }
1059     }
1061     /**
1062      * This function is not part of the public api.
1063      */
1064     function print_headers() {
1065         global $CFG, $OUTPUT;
1067         echo html_writer::start_tag('thead');
1068         echo html_writer::start_tag('tr');
1069         foreach ($this->columns as $column => $index) {
1071             $icon_hide = '';
1072             if ($this->is_collapsible) {
1073                 $icon_hide = $this->show_hide_link($column, $index);
1074             }
1076             $primary_sort_column = '';
1077             $primary_sort_order  = '';
1078             if (reset($this->sess->sortby)) {
1079                 $primary_sort_column = key($this->sess->sortby);
1080                 $primary_sort_order  = current($this->sess->sortby);
1081             }
1083             switch ($column) {
1085                 case 'fullname':
1086                 if ($this->is_sortable($column)) {
1087                     $firstnamesortlink = $this->sort_link(get_string('firstname'),
1088                             'firstname', $primary_sort_column === 'firstname', $primary_sort_order);
1090                     $lastnamesortlink = $this->sort_link(get_string('lastname'),
1091                             'lastname', $primary_sort_column === 'lastname', $primary_sort_order);
1093                     $override = new stdClass();
1094                     $override->firstname = 'firstname';
1095                     $override->lastname = 'lastname';
1096                     $fullnamelanguage = get_string('fullnamedisplay', '', $override);
1098                     if (($CFG->fullnamedisplay == 'firstname lastname') or
1099                         ($CFG->fullnamedisplay == 'firstname') or
1100                         ($CFG->fullnamedisplay == 'language' and $fullnamelanguage == 'firstname lastname' )) {
1101                         $this->headers[$index] = $firstnamesortlink . ' / ' . $lastnamesortlink;
1102                     } else {
1103                         $this->headers[$index] = $lastnamesortlink . ' / ' . $firstnamesortlink;
1104                     }
1105                 }
1106                 break;
1108                 case 'userpic':
1109                     // do nothing, do not display sortable links
1110                 break;
1112                 default:
1113                 if ($this->is_sortable($column)) {
1114                     $this->headers[$index] = $this->sort_link($this->headers[$index],
1115                             $column, $primary_sort_column == $column, $primary_sort_order);
1116                 }
1117             }
1119             $attributes = array(
1120                 'class' => 'header c' . $index . $this->column_class[$column],
1121                 'scope' => 'col',
1122             );
1123             if ($this->headers[$index] === NULL) {
1124                 $content = '&nbsp;';
1125             } else if (!empty($this->sess->collapse[$column])) {
1126                 $content = $icon_hide;
1127             } else {
1128                 if (is_array($this->column_style[$column])) {
1129                     $attributes['style'] = $this->make_styles_string($this->column_style[$column]);
1130                 }
1131                 $content = $this->headers[$index] . html_writer::tag('div',
1132                         $icon_hide, array('class' => 'commands'));
1133             }
1134             echo html_writer::tag('th', $content, $attributes);
1135         }
1137         echo html_writer::end_tag('tr');
1138         echo html_writer::end_tag('thead');
1139     }
1141     /**
1142      * Generate the HTML for the sort icon. This is a helper method used by {@link sort_link()}.
1143      * @param bool $isprimary whether an icon is needed (it is only needed for the primary sort column.)
1144      * @param int $order SORT_ASC or SORT_DESC
1145      * @return string HTML fragment.
1146      */
1147     protected function sort_icon($isprimary, $order) {
1148         global $OUTPUT;
1150         if (!$isprimary) {
1151             return '';
1152         }
1154         if ($order == SORT_ASC) {
1155             return html_writer::empty_tag('img',
1156                     array('src' => $OUTPUT->pix_url('t/down'), 'alt' => get_string('asc')));
1157         } else {
1158             return html_writer::empty_tag('img',
1159                     array('src' => $OUTPUT->pix_url('t/up'), 'alt' => get_string('desc')));
1160         }
1161     }
1163     /**
1164      * Generate the correct tool tip for changing the sort order. This is a
1165      * helper method used by {@link sort_link()}.
1166      * @param bool $isprimary whether the is column is the current primary sort column.
1167      * @param int $order SORT_ASC or SORT_DESC
1168      * @return string the correct title.
1169      */
1170     protected function sort_order_name($isprimary, $order) {
1171         if ($isprimary && $order != SORT_ASC) {
1172             return get_string('desc');
1173         } else {
1174             return get_string('asc');
1175         }
1176     }
1178     /**
1179      * Generate the HTML for the sort link. This is a helper method used by {@link print_headers()}.
1180      * @param string $text the text for the link.
1181      * @param string $column the column name, may be a fake column like 'firstname' or a real one.
1182      * @param bool $isprimary whether the is column is the current primary sort column.
1183      * @param int $order SORT_ASC or SORT_DESC
1184      * @return string HTML fragment.
1185      */
1186     protected function sort_link($text, $column, $isprimary, $order) {
1187         return html_writer::link($this->baseurl->out(false,
1188                 array($this->request[TABLE_VAR_SORT] => $column)),
1189                 $text . get_accesshide(get_string('sortby') . ' ' .
1190                 $text . ' ' . $this->sort_order_name($isprimary, $order))) . ' ' .
1191                 $this->sort_icon($isprimary, $order);
1192     }
1194     /**
1195      * This function is not part of the public api.
1196      */
1197     function start_html() {
1198         global $OUTPUT;
1199         // Do we need to print initial bars?
1200         $this->print_initials_bar();
1202         // Paging bar
1203         if ($this->use_pages) {
1204             $pagingbar = new paging_bar($this->totalrows, $this->currpage, $this->pagesize, $this->baseurl);
1205             $pagingbar->pagevar = $this->request[TABLE_VAR_PAGE];
1206             echo $OUTPUT->render($pagingbar);
1207         }
1209         if (in_array(TABLE_P_TOP, $this->showdownloadbuttonsat)) {
1210             echo $this->download_buttons();
1211         }
1213         $this->wrap_html_start();
1214         // Start of main data table
1216         echo html_writer::start_tag('div', array('class' => 'no-overflow'));
1217         echo html_writer::start_tag('table', $this->attributes);
1219     }
1221     /**
1222      * This function is not part of the public api.
1223      * @param array $styles CSS-property => value
1224      * @return string values suitably to go in a style="" attribute in HTML.
1225      */
1226     function make_styles_string($styles) {
1227         if (empty($styles)) {
1228             return null;
1229         }
1231         $string = '';
1232         foreach($styles as $property => $value) {
1233             $string .= $property . ':' . $value . ';';
1234         }
1235         return $string;
1236     }
1240 /**
1241  * @package   moodlecore
1242  * @copyright 1999 onwards Martin Dougiamas  {@link http://moodle.com}
1243  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
1244  */
1245 class table_sql extends flexible_table {
1247     public $countsql = NULL;
1248     public $countparams = NULL;
1249     /**
1250      * @var object sql for querying db. Has fields 'fields', 'from', 'where', 'params'.
1251      */
1252     public $sql = NULL;
1253     /**
1254      * @var array Data fetched from the db.
1255      */
1256     public $rawdata = NULL;
1258     /**
1259      * @var bool Overriding default for this.
1260      */
1261     public $is_sortable    = true;
1262     /**
1263      * @var bool Overriding default for this.
1264      */
1265     public $is_collapsible = true;
1267     /**
1268      * @param string $uniqueid a string identifying this table.Used as a key in
1269      *                          session  vars.
1270      */
1271     function __construct($uniqueid) {
1272         parent::__construct($uniqueid);
1273         // some sensible defaults
1274         $this->set_attribute('cellspacing', '0');
1275         $this->set_attribute('class', 'generaltable generalbox');
1276     }
1278     /**
1279      * Take the data returned from the db_query and go through all the rows
1280      * processing each col using either col_{columnname} method or other_cols
1281      * method or if other_cols returns NULL then put the data straight into the
1282      * table.
1283      */
1284     function build_table() {
1285         if ($this->rawdata) {
1286             foreach ($this->rawdata as $row) {
1287                 $formattedrow = $this->format_row($row);
1288                 $this->add_data_keyed($formattedrow,
1289                         $this->get_row_class($row));
1290             }
1291         }
1292     }
1294     /**
1295      * Get any extra classes names to add to this row in the HTML.
1296      * @param $row array the data for this row.
1297      * @return string added to the class="" attribute of the tr.
1298      */
1299     function get_row_class($row) {
1300         return '';
1301     }
1303     /**
1304      * This is only needed if you want to use different sql to count rows.
1305      * Used for example when perhaps all db JOINS are not needed when counting
1306      * records. You don't need to call this function the count_sql
1307      * will be generated automatically.
1308      *
1309      * We need to count rows returned by the db seperately to the query itself
1310      * as we need to know how many pages of data we have to display.
1311      */
1312     function set_count_sql($sql, array $params = NULL) {
1313         $this->countsql = $sql;
1314         $this->countparams = $params;
1315     }
1317     /**
1318      * Set the sql to query the db. Query will be :
1319      *      SELECT $fields FROM $from WHERE $where
1320      * Of course you can use sub-queries, JOINS etc. by putting them in the
1321      * appropriate clause of the query.
1322      */
1323     function set_sql($fields, $from, $where, array $params = NULL) {
1324         $this->sql = new stdClass();
1325         $this->sql->fields = $fields;
1326         $this->sql->from = $from;
1327         $this->sql->where = $where;
1328         $this->sql->params = $params;
1329     }
1331     /**
1332      * Query the db. Store results in the table object for use by build_table.
1333      *
1334      * @param int $pagesize size of page for paginated displayed table.
1335      * @param bool $useinitialsbar do you want to use the initials bar. Bar
1336      * will only be used if there is a fullname column defined for the table.
1337      */
1338     function query_db($pagesize, $useinitialsbar=true) {
1339         global $DB;
1340         if (!$this->is_downloading()) {
1341             if ($this->countsql === NULL) {
1342                 $this->countsql = 'SELECT COUNT(1) FROM '.$this->sql->from.' WHERE '.$this->sql->where;
1343                 $this->countparams = $this->sql->params;
1344             }
1345             $grandtotal = $DB->count_records_sql($this->countsql, $this->countparams);
1346             if ($useinitialsbar && !$this->is_downloading()) {
1347                 $this->initialbars($grandtotal > $pagesize);
1348             }
1350             list($wsql, $wparams) = $this->get_sql_where();
1351             if ($wsql) {
1352                 $this->countsql .= ' AND '.$wsql;
1353                 $this->countparams = array_merge($this->countparams, $wparams);
1355                 $this->sql->where .= ' AND '.$wsql;
1356                 $this->sql->params = array_merge($this->sql->params, $wparams);
1358                 $total  = $DB->count_records_sql($this->countsql, $this->countparams);
1359             } else {
1360                 $total = $grandtotal;
1361             }
1363             $this->pagesize($pagesize, $total);
1364         }
1366         // Fetch the attempts
1367         $sort = $this->get_sql_sort();
1368         if ($sort) {
1369             $sort = "ORDER BY $sort";
1370         }
1371         $sql = "SELECT
1372                 {$this->sql->fields}
1373                 FROM {$this->sql->from}
1374                 WHERE {$this->sql->where}
1375                 {$sort}";
1377         if (!$this->is_downloading()) {
1378             $this->rawdata = $DB->get_records_sql($sql, $this->sql->params, $this->get_page_start(), $this->get_page_size());
1379         } else {
1380             $this->rawdata = $DB->get_records_sql($sql, $this->sql->params);
1381         }
1382     }
1384     /**
1385      * Convenience method to call a number of methods for you to display the
1386      * table.
1387      */
1388     function out($pagesize, $useinitialsbar, $downloadhelpbutton='') {
1389         global $DB;
1390         if (!$this->columns) {
1391             $onerow = $DB->get_record_sql("SELECT {$this->sql->fields} FROM {$this->sql->from} WHERE {$this->sql->where}", $this->sql->params);
1392             //if columns is not set then define columns as the keys of the rows returned
1393             //from the db.
1394             $this->define_columns(array_keys((array)$onerow));
1395             $this->define_headers(array_keys((array)$onerow));
1396         }
1397         $this->setup();
1398         $this->query_db($pagesize, $useinitialsbar);
1399         $this->build_table();
1400         $this->finish_output();
1401     }
1405 /**
1406  * @package   moodlecore
1407  * @copyright 1999 onwards Martin Dougiamas  {@link http://moodle.com}
1408  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
1409  */
1410 class table_default_export_format_parent {
1411     /**
1412      * @var flexible_table or child class reference pointing to table class
1413      * object from which to export data.
1414      */
1415     var $table;
1417     /**
1418      * @var bool output started. Keeps track of whether any output has been
1419      * started yet.
1420      */
1421     var $documentstarted = false;
1422     function table_default_export_format_parent(&$table) {
1423         $this->table =& $table;
1424     }
1426     function set_table(&$table) {
1427         $this->table =& $table;
1428     }
1430     function add_data($row) {
1431         return false;
1432     }
1434     function add_seperator() {
1435         return false;
1436     }
1438     function document_started() {
1439         return $this->documentstarted;
1440     }
1441     /**
1442      * Given text in a variety of format codings, this function returns
1443      * the text as safe HTML or as plain text dependent on what is appropriate
1444      * for the download format. The default removes all tags.
1445      */
1446     function format_text($text, $format=FORMAT_MOODLE, $options=NULL, $courseid=NULL) {
1447         //use some whitespace to indicate where there was some line spacing.
1448         $text = str_replace(array('</p>', "\n", "\r"), '   ', $text);
1449         return strip_tags($text);
1450     }
1454 /**
1455  * @package   moodlecore
1456  * @copyright 1999 onwards Martin Dougiamas  {@link http://moodle.com}
1457  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
1458  */
1459 class table_spreadsheet_export_format_parent extends table_default_export_format_parent {
1460     var $rownum;
1461     var $workbook;
1462     var $worksheet;
1463     /**
1464      * @var object format object - format for normal table cells
1465      */
1466     var $formatnormal;
1467     /**
1468      * @var object format object - format for header table cells
1469      */
1470     var $formatheaders;
1472     /**
1473      * should be overriden in child class.
1474      */
1475     var $fileextension;
1477     /**
1478      * This method will be overridden in the child class.
1479      */
1480     function define_workbook() {
1481     }
1483     function start_document($filename) {
1484         $filename = $filename.'.'.$this->fileextension;
1485         $this->define_workbook();
1486         // format types
1487         $this->formatnormal =& $this->workbook->add_format();
1488         $this->formatnormal->set_bold(0);
1489         $this->formatheaders =& $this->workbook->add_format();
1490         $this->formatheaders->set_bold(1);
1491         $this->formatheaders->set_align('center');
1492         // Sending HTTP headers
1493         $this->workbook->send($filename);
1494         $this->documentstarted = true;
1495     }
1497     function start_table($sheettitle) {
1498         $this->worksheet =& $this->workbook->add_worksheet($sheettitle);
1499         $this->rownum=0;
1500     }
1502     function output_headers($headers) {
1503         $colnum = 0;
1504         foreach ($headers as $item) {
1505             $this->worksheet->write($this->rownum,$colnum,$item,$this->formatheaders);
1506             $colnum++;
1507         }
1508         $this->rownum++;
1509     }
1511     function add_data($row) {
1512         $colnum = 0;
1513         foreach ($row as $item) {
1514             $this->worksheet->write($this->rownum,$colnum,$item,$this->formatnormal);
1515             $colnum++;
1516         }
1517         $this->rownum++;
1518         return true;
1519     }
1521     function add_seperator() {
1522         $this->rownum++;
1523         return true;
1524     }
1526     function finish_table() {
1527     }
1529     function finish_document() {
1530         $this->workbook->close();
1531         exit;
1532     }
1536 /**
1537  * @package   moodlecore
1538  * @copyright 1999 onwards Martin Dougiamas  {@link http://moodle.com}
1539  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
1540  */
1541 class table_excel_export_format extends table_spreadsheet_export_format_parent {
1542     var $fileextension = 'xls';
1544     function define_workbook() {
1545         global $CFG;
1546         require_once("$CFG->libdir/excellib.class.php");
1547         // Creating a workbook
1548         $this->workbook = new MoodleExcelWorkbook("-");
1549     }
1554 /**
1555  * @package   moodlecore
1556  * @copyright 1999 onwards Martin Dougiamas  {@link http://moodle.com}
1557  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
1558  */
1559 class table_ods_export_format extends table_spreadsheet_export_format_parent {
1560     var $fileextension = 'ods';
1561     function define_workbook() {
1562         global $CFG;
1563         require_once("$CFG->libdir/odslib.class.php");
1564         // Creating a workbook
1565         $this->workbook = new MoodleODSWorkbook("-");
1566     }
1570 /**
1571  * @package   moodlecore
1572  * @copyright 1999 onwards Martin Dougiamas  {@link http://moodle.com}
1573  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
1574  */
1575 class table_text_export_format_parent extends table_default_export_format_parent {
1576     protected $seperator = "tab";
1577     protected $mimetype = 'text/tab-separated-values';
1578     protected $ext = '.txt';
1579     protected $myexporter;
1581     public function __construct() {
1582         $this->myexporter = new csv_export_writer($this->seperator, '"', $this->mimetype);
1583     }
1585     public function start_document($filename) {
1586         $this->filename = $filename;
1587         $this->documentstarted = true;
1588         $this->myexporter->set_filename($filename, $this->ext);
1589     }
1591     public function start_table($sheettitle) {
1592         //nothing to do here
1593     }
1595     public function output_headers($headers) {
1596         $this->myexporter->add_data($headers);
1597     }
1599     public function add_data($row) {
1600         $this->myexporter->add_data($row);
1601         return true;
1602     }
1604     public function finish_table() {
1605         //nothing to do here
1606     }
1608     public function finish_document() {
1609         $this->myexporter->download_file();
1610         exit;
1611     }
1613     /**
1614      * Format a row of data.
1615      * @param array $data
1616      */
1617     protected function format_row($data) {
1618         $escapeddata = array();
1619         foreach ($data as $value) {
1620             $escapeddata[] = '"' . str_replace('"', '""', $value) . '"';
1621         }
1622         return implode($this->seperator, $escapeddata) . "\n";
1623     }
1627 /**
1628  * @package   moodlecore
1629  * @copyright 1999 onwards Martin Dougiamas  {@link http://moodle.com}
1630  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
1631  */
1632 class table_tsv_export_format extends table_text_export_format_parent {
1633     protected $seperator = "tab";
1634     protected $mimetype = 'text/tab-separated-values';
1635     protected $ext = '.txt';
1638 require_once($CFG->libdir . '/csvlib.class.php');
1639 /**
1640  * @package   moodlecore
1641  * @copyright 1999 onwards Martin Dougiamas  {@link http://moodle.com}
1642  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
1643  */
1644 class table_csv_export_format extends table_text_export_format_parent {
1645     protected $seperator = "comma";
1646     protected $mimetype = 'text/csv';
1647     protected $ext = '.csv';
1650 /**
1651  * @package   moodlecore
1652  * @copyright 1999 onwards Martin Dougiamas  {@link http://moodle.com}
1653  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
1654  */
1655 class table_xhtml_export_format extends table_default_export_format_parent {
1656     function start_document($filename) {
1657         header("Content-Type: application/download\n");
1658         header("Content-Disposition: attachment; filename=\"$filename.html\"");
1659         header("Expires: 0");
1660         header("Cache-Control: must-revalidate,post-check=0,pre-check=0");
1661         header("Pragma: public");
1662         //html headers
1663         echo <<<EOF
1664 <?xml version="1.0" encoding="UTF-8"?>
1665 <!DOCTYPE html
1666   PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
1667   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
1669 <html xmlns="http://www.w3.org/1999/xhtml"
1670   xml:lang="en" lang="en">
1671 <head>
1672 <style type="text/css">/*<![CDATA[*/
1674 .flexible th {
1675 white-space:normal;
1677 th.header, td.header, div.header {
1678 border-color:#DDDDDD;
1679 background-color:lightGrey;
1681 .flexible th {
1682 white-space:nowrap;
1684 th {
1685 font-weight:bold;
1688 .generaltable {
1689 border-style:solid;
1691 .generalbox {
1692 border-style:solid;
1694 body, table, td, th {
1695 font-family:Arial,Verdana,Helvetica,sans-serif;
1696 font-size:100%;
1698 td {
1699     border-style:solid;
1700     border-width:1pt;
1702 table {
1703     border-collapse:collapse;
1704     border-spacing:0pt;
1705     width:80%;
1706     margin:auto;
1709 h1, h2 {
1710     text-align:center;
1712 .bold {
1713 font-weight:bold;
1715 .mdl-align {
1716     text-align:center;
1718 /*]]>*/</style>
1719 <title>$filename</title>
1720 </head>
1721 <body>
1722 EOF;
1723         $this->documentstarted = true;
1724     }
1726     function start_table($sheettitle) {
1727         $this->table->sortable(false);
1728         $this->table->collapsible(false);
1729         echo "<h2>{$sheettitle}</h2>";
1730         $this->table->start_html();
1731     }
1733     function output_headers($headers) {
1734         $this->table->print_headers();
1735         echo html_writer::start_tag('tbody');
1736     }
1738     function add_data($row) {
1739         $this->table->print_row($row);
1740         return true;
1741     }
1743     function add_seperator() {
1744         $this->table->print_row(NULL);
1745         return true;
1746     }
1748     function finish_table() {
1749         $this->table->finish_html();
1750     }
1752     function finish_document() {
1753         echo "</body>\n</html>";
1754         exit;
1755     }
1757     function format_text($text, $format=FORMAT_MOODLE, $options=NULL, $courseid=NULL) {
1758         if (is_null($options)) {
1759             $options = new stdClass;
1760         }
1761         //some sensible defaults
1762         if (!isset($options->para)) {
1763             $options->para = false;
1764         }
1765         if (!isset($options->newlines)) {
1766             $options->newlines = false;
1767         }
1768         if (!isset($options->smiley)) {
1769             $options->smiley = false;
1770         }
1771         if (!isset($options->filter)) {
1772             $options->filter = false;
1773         }
1774         return format_text($text, $format, $options);
1775     }