/**
  * Builds a tree of files This function is then called recursively.
  *
  * @static
  * @todo take $search into account, and respect a threshold for dynamic loading
  * @param file_info $fileinfo an object returned by file_browser::get_file_info()
  * @param string $search searched string
  * @param bool $dynamicmode no recursive call is done when in dynamic mode
  * @param array $list the array containing the files under the passed $fileinfo
  * @return int the number of files found
  */
 public static function build_tree($fileinfo, $search, $dynamicmode, &$list)
 {
     global $CFG, $OUTPUT;
     $filecount = 0;
     $children = $fileinfo->get_children();
     foreach ($children as $child) {
         $filename = $child->get_visible_name();
         $filesize = $child->get_filesize();
         $filesize = $filesize ? display_size($filesize) : '';
         $filedate = $child->get_timemodified();
         $filedate = $filedate ? userdate($filedate) : '';
         $filetype = $child->get_mimetype();
         if ($child->is_directory()) {
             $path = array();
             $level = $child->get_parent();
             while ($level) {
                 $params = $level->get_params();
                 $path[] = array($params['filepath'], $level->get_visible_name());
                 $level = $level->get_parent();
             }
             $tmp = array('title' => $child->get_visible_name(), 'size' => 0, 'date' => $filedate, 'path' => array_reverse($path), 'thumbnail' => $OUTPUT->pix_url(file_folder_icon(90))->out(false));
             //if ($dynamicmode && $child->is_writable()) {
             //    $tmp['children'] = array();
             //} else {
             // if folder name matches search, we send back all files contained.
             $_search = $search;
             if ($search && stristr($tmp['title'], $search) !== false) {
                 $_search = false;
             }
             $tmp['children'] = array();
             $_filecount = repository::build_tree($child, $_search, $dynamicmode, $tmp['children']);
             if ($search && $_filecount) {
                 $tmp['expanded'] = 1;
             }
             //}
             if (!$search || $_filecount || stristr($tmp['title'], $search) !== false) {
                 $filecount += $_filecount;
                 $list[] = $tmp;
             }
         } else {
             // not a directory
             // skip the file, if we're in search mode and it's not a match
             if ($search && stristr($filename, $search) === false) {
                 continue;
             }
             $params = $child->get_params();
             $source = serialize(array($params['contextid'], $params['component'], $params['filearea'], $params['itemid'], $params['filepath'], $params['filename']));
             $list[] = array('title' => $filename, 'size' => $filesize, 'date' => $filedate, 'source' => base64_encode($source), 'icon' => $OUTPUT->pix_url(file_file_icon($child, 24))->out(false), 'thumbnail' => $OUTPUT->pix_url(file_file_icon($child, 90))->out(false));
             $filecount++;
         }
     }
     return $filecount;
 }

 /**
  * Constructor
  *
  * @param file_browser $browser file browser instance
  * @param stdClass $context context object
  * @param stdClass $course course object
  * @param file_info_context_course $courseinfo file info instance
  */
 public function __construct($browser, $context, $course, file_info_context_course $courseinfo)
 {
     parent::__construct($browser, $context);
     $this->course = $course;
     $this->courseinfo = $courseinfo;
 }

 /**
  * Converts file_info object to element of repository return path
  *
  * @param file_info $fileinfo
  * @return array
  */
 private function get_node_path(file_info $fileinfo)
 {
     $encodedpath = base64_encode(json_encode($fileinfo->get_params()));
     return array('path' => $encodedpath, 'name' => $fileinfo->get_visible_name());
 }

 /**
  * Constructor of moodle_file_tree_viewer class
  * @param file_info $file_info
  * @param array $options
  */
 public function __construct(file_info $file_info, array $options = null)
 {
     global $CFG;
     //note: this MUST NOT use get_file_storage() !!!!!!!!!!!!!!!!!!!!!!!!!!!!
     $this->options = (array) $options;
     $this->context = $options['context'];
     $this->tree = array();
     $children = $file_info->get_children();
     $current_file_params = $file_info->get_params();
     $parent_info = $file_info->get_parent();
     $level = $parent_info;
     $this->path = array();
     while ($level) {
         $params = $level->get_params();
         $context = context::instance_by_id($params['contextid']);
         // $this->context is current context
         if ($context->id != $this->context->id or empty($params['filearea'])) {
             break;
         }
         // unset unused parameters
         unset($params['component']);
         unset($params['filearea']);
         unset($params['filename']);
         unset($params['itemid']);
         $url = new moodle_url('/files/index.php', $params);
         $this->path[] = html_writer::link($url, $level->get_visible_name());
         $level = $level->get_parent();
     }
     $this->path = array_reverse($this->path);
     if ($current_file_params['filepath'] != '/') {
         $this->path[] = $file_info->get_visible_name();
     }
     foreach ($children as $child) {
         $filedate = $child->get_timemodified();
         $filesize = $child->get_filesize();
         $mimetype = $child->get_mimetype();
         $params = $child->get_params();
         unset($params['component']);
         unset($params['filearea']);
         unset($params['filename']);
         unset($params['itemid']);
         $fileitem = array('params' => $params, 'filename' => $child->get_visible_name(), 'mimetype' => $child->get_mimetype(), 'filedate' => $filedate ? $filedate : '', 'filesize' => $filesize ? $filesize : '');
         $url = new moodle_url('/files/index.php', $params);
         if ($child->is_directory()) {
             $fileitem['isdir'] = true;
             $fileitem['url'] = $url->out(false);
         } else {
             $fileitem['url'] = $child->get_url();
         }
         $this->tree[] = $fileitem;
     }
 }

 /**
  * Creates an object
  *
  * @param file_info $fileinfo
  * @param repository $repository
  * @param repository_local_file $parent
  */
 private function __construct(file_info $fileinfo, repository $repository, repository_local_file $parent = null) {
     $this->repository = $repository;
     $this->fileinfo = $fileinfo;
     $this->isdir = $fileinfo->is_directory();
     if (!$this->isdir) {
         $node = array('title' => $this->fileinfo->get_visible_name());
         $this->isempty = !$repository->filter($node);
         $this->skip = false;
     }
 }

 public function __construct($browser, $course, $cm, $context, $areas, $filearea) {
     parent::__construct($browser, $context);
     $this->course   = $course;
     $this->cm       = $cm;
     $this->areas    = $areas;
     $this->filearea = $filearea;
 }

 public function __construct($browser, $course, $cm, $context, $areas)
 {
     global $DB;
     parent::__construct($browser, $context);
     $this->course = $course;
     $this->cm = $cm;
     $this->areas = $areas;
 }

 public function __construct($browser, $context, $storedfile, $urlbase, $topvisiblename, $itemidused, $readaccess, $writeaccess, $areaonly)
 {
     parent::__construct($browser, $context);
     $this->lf = $storedfile;
     $this->urlbase = $urlbase;
     $this->topvisiblename = $topvisiblename;
     $this->itemidused = $itemidused;
     $this->readaccess = $readaccess;
     $this->writeaccess = $writeaccess;
     $this->areaonly = $areaonly;
 }

 public function __construct($browser, $context)
 {
     global $DB, $USER;
     parent::__construct($browser, $context);
     $userid = $context->instanceid;
     if ($userid == $USER->id) {
         $this->user = $USER;
     } else {
         // if context exists user record should exist too ;-)
         $this->user = $DB->get_record('user', array('id' => $userid));
     }
 }

 public function __construct($browser, $context, $course, $cm, $modname)
 {
     global $CFG;
     parent::__construct($browser, $context);
     $this->course = $course;
     $this->cm = $cm;
     $this->modname = $modname;
     include_once "{$CFG->dirroot}/mod/{$modname}/lib.php";
     //find out all supported areas
     $functionname = 'mod_' . $modname . '_get_file_areas';
     $functionname_old = $modname . '_get_file_areas';
     if (function_exists($functionname)) {
         $this->areas = $functionname($course, $cm, $context);
     } else {
         if (function_exists($functionname_old)) {
             $this->areas = $functionname_old($course, $cm, $context);
         } else {
             $this->areas = array();
         }
     }
     unset($this->areas['intro']);
     // hardcoded, ignore attempts to override it
 }

 public function __construct($browser, $context, $course)
 {
     global $DB;
     parent::__construct($browser, $context);
     $this->course = $course;
 }

 /**
  * Constructor (in case you did not realize it ;-)
  *
  * @param file_browser $browser
  * @param stdClass $course
  * @param stdClass $cm
  * @param stdClass $context
  * @param array $areas
  * @param string $filearea
  */
 public function __construct($browser, $course, $cm, $context, $areas, $filearea)
 {
     parent::__construct($browser, $context);
     $this->browser = $browser;
     $this->course = $course;
     $this->cm = $cm;
     $this->component = 'mod_data';
     $this->context = $context;
     $this->areas = $areas;
     $this->filearea = $filearea;
 }

 /**
  * Constructor
  *
  * @param file_browser $browser file browser instance
  * @param stdClass $context context object
  * @param stdClass $category category object
  */
 public function __construct($browser, $context, $category)
 {
     parent::__construct($browser, $context);
     $this->category = $category;
 }

 /**
  * Constructor
  *
  * @param file_browser $browser
  * @param stdClass $context
  * @param stdClass $user
  */
 public function __construct($browser, $context, $user)
 {
     parent::__construct($browser, $context);
     $this->user = $user;
 }

 /**
  * Constructor
  *
  * @param file_browser $browser file_browser instance
  * @param stdClass $context context object
  */
 public function __construct($browser, $context)
 {
     parent::__construct($browser, $context);
 }

 public function __construct($browser)
 {
     parent::__construct($browser, get_context_instance(CONTEXT_SYSTEM));
 }