engine/lib/views.php

Go to the documentation of this file.

<?php
global $CURRENT_SYSTEM_VIEWTYPE;
$CURRENT_SYSTEM_VIEWTYPE = "";

function elgg_set_viewtype($viewtype = "") {
    global $CURRENT_SYSTEM_VIEWTYPE;

    $CURRENT_SYSTEM_VIEWTYPE = $viewtype;

    return true;
}

function elgg_get_viewtype() {
    global $CURRENT_SYSTEM_VIEWTYPE, $CONFIG;

    if ($CURRENT_SYSTEM_VIEWTYPE != "") {
        return $CURRENT_SYSTEM_VIEWTYPE;
    }

    $viewtype = get_input('view', '', false);
    if (is_string($viewtype) && $viewtype !== '') {
        // only word characters allowed.
        if (!preg_match('/\W/', $viewtype)) {
            return $viewtype;
        }
    }

    if (!empty($CONFIG->view)) {
        return $CONFIG->view;
    }

    return 'default';
}

function elgg_register_viewtype($view_type) {
    global $CONFIG;

    if (!isset($CONFIG->view_types) || !is_array($CONFIG->view_types)) {
        $CONFIG->view_types = array();
    }

    if (!in_array($view_type, $CONFIG->view_types)) {
        $CONFIG->view_types[] = $view_type;
    }

    return true;
}

function elgg_is_valid_view_type($view_type) {
    global $CONFIG;

    if (!isset($CONFIG->view_types) || !is_array($CONFIG->view_types)) {
        return FALSE;
    }

    return in_array($view_type, $CONFIG->view_types);
}

function elgg_register_viewtype_fallback($viewtype) {
    global $CONFIG;

    if (!isset($CONFIG->viewtype)) {
        $CONFIG->viewtype = new stdClass;
    }

    if (!isset($CONFIG->viewtype->fallback)) {
        $CONFIG->viewtype->fallback = array();
    }

    $CONFIG->viewtype->fallback[] = $viewtype;
}

function elgg_does_viewtype_fallback($viewtype) {
    global $CONFIG;

    if (isset($CONFIG->viewtype) && isset($CONFIG->viewtype->fallback)) {
        return in_array($viewtype, $CONFIG->viewtype->fallback);
    }

    return FALSE;
}

function elgg_register_ajax_view($view) {
    global $CONFIG;

    if (!isset($CONFIG->allowed_ajax_views)) {
        $CONFIG->allowed_ajax_views = array();
    }

    $CONFIG->allowed_ajax_views[$view] = true;
}

function elgg_unregister_ajax_view($view) {
    global $CONFIG;

    if (isset($CONFIG->allowed_ajax_views[$view])) {
        unset($CONFIG->allowed_ajax_views[$view]);
    }
}

function elgg_get_view_location($view, $viewtype = '') {
    global $CONFIG;

    if (empty($viewtype)) {
        $viewtype = elgg_get_viewtype();
    }

    if (!isset($CONFIG->views->locations[$viewtype][$view])) {
        if (!isset($CONFIG->viewpath)) {
            return dirname(dirname(dirname(__FILE__))) . "/views/";
        } else {
            return $CONFIG->viewpath;
        }
    } else {
        return $CONFIG->views->locations[$viewtype][$view];
    }
}

function elgg_set_view_location($view, $location, $viewtype = '') {
    global $CONFIG;

    if (empty($viewtype)) {
        $viewtype = 'default';
    }

    if (!isset($CONFIG->views)) {
        $CONFIG->views = new stdClass;
    }

    if (!isset($CONFIG->views->locations)) {
        $CONFIG->views->locations = array($viewtype => array($view => $location));

    } else if (!isset($CONFIG->views->locations[$viewtype])) {
        $CONFIG->views->locations[$viewtype] = array($view => $location);

    } else {
        $CONFIG->views->locations[$viewtype][$view] = $location;
    }
}

function elgg_view_exists($view, $viewtype = '', $recurse = true) {
    global $CONFIG;

    // Detect view type
    if (empty($viewtype)) {
        $viewtype = elgg_get_viewtype();
    }

    if (!isset($CONFIG->views->locations[$viewtype][$view])) {
        if (!isset($CONFIG->viewpath)) {
            $location = dirname(dirname(dirname(__FILE__))) . "/views/";
        } else {
            $location = $CONFIG->viewpath;
        }
    } else {
        $location = $CONFIG->views->locations[$viewtype][$view];
    }

    if (file_exists("{$location}{$viewtype}/{$view}.php")) {
        return true;
    }

    // If we got here then check whether this exists as an extension
    // We optionally recursively check whether the extended view exists also for the viewtype
    if ($recurse && isset($CONFIG->views->extensions[$view])) {
        foreach ($CONFIG->views->extensions[$view] as $view_extension) {
            // do not recursively check to stay away from infinite loops
            if (elgg_view_exists($view_extension, $viewtype, false)) {
                return true;
            }
        }
    }

    // Now check if the default view exists if the view is registered as a fallback
    if ($viewtype != 'default' && elgg_does_viewtype_fallback($viewtype)) {
        return elgg_view_exists($view, 'default');
    }

    return false;
}

function elgg_view($view, $vars = array(), $bypass = false, $ignored = false, $viewtype = '') {
    global $CONFIG;

    if (!is_string($view) || !is_string($viewtype)) {
        elgg_log("View and Viewtype in views must be a strings: $view", 'NOTICE');
        return '';
    }
    // basic checking for bad paths
    if (strpos($view, '..') !== false) {
        return '';
    }

    if (!is_array($vars)) {
        elgg_log("Vars in views must be an array: $view", 'ERROR');
        $vars = array();
    }

    // Get the current viewtype
    if ($viewtype === '') {
        $viewtype = elgg_get_viewtype();
    } elseif (preg_match('/\W/', $viewtype)) {
        // Viewtypes can only be alphanumeric
        return '';
    }

    $view_orig = $view;

    // Trigger the pagesetup event
    if (!isset($CONFIG->pagesetupdone) && $CONFIG->boot_complete) {
        $CONFIG->pagesetupdone = true;
        elgg_trigger_event('pagesetup', 'system');
    }

    // @warning - plugin authors: do not expect user, config, and url to be
    // set by elgg_view() in the future. Instead, use elgg_get_logged_in_user_entity(),
    // elgg_get_config(), and elgg_get_site_url() in your views.
    if (!isset($vars['user'])) {
        $vars['user'] = elgg_get_logged_in_user_entity();
    }
    if (!isset($vars['config'])) {
        $vars['config'] = $CONFIG;
    }
    if (!isset($vars['url'])) {
        $vars['url'] = elgg_get_site_url();
    }

    // full_view is the new preferred key for full view on entities @see elgg_view_entity()
    // check if full_view is set because that means we've already rewritten it and this is
    // coming from another view passing $vars directly.
    if (isset($vars['full']) && !isset($vars['full_view'])) {
        elgg_deprecated_notice("Use \$vars['full_view'] instead of \$vars['full']", 1.8, 2);
        $vars['full_view'] = $vars['full'];
    }
    if (isset($vars['full_view'])) {
        $vars['full'] = $vars['full_view'];
    }

    // internalname => name (1.8)
    if (isset($vars['internalname']) && !isset($vars['__ignoreInternalname']) && !isset($vars['name'])) {
        elgg_deprecated_notice('You should pass $vars[\'name\'] now instead of $vars[\'internalname\']', 1.8, 2);
        $vars['name'] = $vars['internalname'];
    } elseif (isset($vars['name'])) {
        if (!isset($vars['internalname'])) {
            $vars['__ignoreInternalname'] = '';
        }
        $vars['internalname'] = $vars['name'];
    }

    // internalid => id (1.8)
    if (isset($vars['internalid']) && !isset($vars['__ignoreInternalid']) && !isset($vars['name'])) {
        elgg_deprecated_notice('You should pass $vars[\'id\'] now instead of $vars[\'internalid\']', 1.8, 2);
        $vars['id'] = $vars['internalid'];
    } elseif (isset($vars['id'])) {
        if (!isset($vars['internalid'])) {
            $vars['__ignoreInternalid'] = '';
        }
        $vars['internalid'] = $vars['id'];
    }

    // If it's been requested, pass off to a template handler instead
    if ($bypass == false && isset($CONFIG->template_handler) && !empty($CONFIG->template_handler)) {
        $template_handler = $CONFIG->template_handler;
        if (is_callable($template_handler)) {
            return call_user_func($template_handler, $view, $vars);
        }
    }

    // Set up any extensions to the requested view
    if (isset($CONFIG->views->extensions[$view])) {
        $viewlist = $CONFIG->views->extensions[$view];
    } else {
        $viewlist = array(500 => $view);
    }

    // Start the output buffer, find the requested view file, and execute it
    ob_start();

    foreach ($viewlist as $priority => $view) {

        $view_location = elgg_get_view_location($view, $viewtype);
        $view_file = "$view_location$viewtype/$view.php";

        // try to include view
        if (!file_exists($view_file) || !include($view_file)) {
            // requested view does not exist
            $error = "$viewtype/$view view does not exist.";

            // attempt to load default view
            if ($viewtype !== 'default' && elgg_does_viewtype_fallback($viewtype)) {

                $default_location = elgg_get_view_location($view, 'default');
                $default_view_file = "{$default_location}default/$view.php";

                if (file_exists($default_view_file) && include($default_view_file)) {
                    // default view found
                    $error .= " Using default/$view instead.";
                } else {
                    // no view found at all
                    $error = "Neither $viewtype/$view nor default/$view view exists.";
                }
            }

            // log warning
            elgg_log($error, 'NOTICE');
        }
    }

    // Save the output buffer into the $content variable
    $content = ob_get_clean();

    // Plugin hook
    $params = array('view' => $view_orig, 'vars' => $vars, 'viewtype' => $viewtype);
    $content = elgg_trigger_plugin_hook('view', $view_orig, $params, $content);

    // backward compatibility with less granular hook will be gone in 2.0
    $content_tmp = elgg_trigger_plugin_hook('display', 'view', $params, $content);

    if ($content_tmp !== $content) {
        $content = $content_tmp;
        elgg_deprecated_notice('The display:view plugin hook is deprecated by view:view_name', 1.8);
    }

    return $content;
}

function elgg_extend_view($view, $view_extension, $priority = 501) {
    global $CONFIG;

    if (!isset($CONFIG->views)) {
        $CONFIG->views = (object) array(
            'extensions' => array(),
        );
        $CONFIG->views->extensions[$view][500] = (string)$view;
    } else {
        if (!isset($CONFIG->views->extensions[$view])) {
            $CONFIG->views->extensions[$view][500] = (string)$view;
        }
    }

    // raise priority until it doesn't match one already registered
    while (isset($CONFIG->views->extensions[$view][$priority])) {
        $priority++;
    }

    $CONFIG->views->extensions[$view][$priority] = (string)$view_extension;
    ksort($CONFIG->views->extensions[$view]);
}

function elgg_unextend_view($view, $view_extension) {
    global $CONFIG;

    if (!isset($CONFIG->views->extensions[$view])) {
        return FALSE;
    }

    $priority = array_search($view_extension, $CONFIG->views->extensions[$view]);
    if ($priority === FALSE) {
        return FALSE;
    }

    unset($CONFIG->views->extensions[$view][$priority]);

    return TRUE;
}

function elgg_view_page($title, $body, $page_shell = 'default', $vars = array()) {

    $messages = null;
    if (count_messages()) {
        // get messages - try for errors first
        $messages = system_messages(NULL, "error");
        if (count($messages["error"]) == 0) {
            // no errors so grab rest of messages
            $messages = system_messages(null, "");
        } else {
            // we have errors - clear out remaining messages
            system_messages(null, "");
        }
    }

    $vars['title'] = $title;
    $vars['body'] = $body;
    $vars['sysmessages'] = $messages;

    $vars = elgg_trigger_plugin_hook('output:before', 'page', null, $vars);
    
    // check for deprecated view
    if ($page_shell == 'default' && elgg_view_exists('pageshells/pageshell')) {
        elgg_deprecated_notice("pageshells/pageshell is deprecated by page/$page_shell", 1.8);
        $output = elgg_view('pageshells/pageshell', $vars);
    } else {
        $output = elgg_view("page/$page_shell", $vars);
    }

    $vars['page_shell'] = $page_shell;

    // Allow plugins to mod output
    return elgg_trigger_plugin_hook('output', 'page', $vars, $output);
}

function elgg_view_layout($layout_name, $vars = array()) {

    if (is_string($vars) || $vars === null) {
        elgg_deprecated_notice("The use of unlimited optional string arguments in elgg_view_layout() was deprecated in favor of an options array", 1.8);
        $arg = 1;
        $param_array = array();
        while ($arg < func_num_args()) {
            $param_array['area' . $arg] = func_get_arg($arg);
            $arg++;
        }
    } else {
        $param_array = $vars;
    }

    $params = elgg_trigger_plugin_hook('output:before', 'layout', null, $param_array);

    // check deprecated location
    if (elgg_view_exists("canvas/layouts/$layout_name")) {
        elgg_deprecated_notice("canvas/layouts/$layout_name is deprecated by page/layouts/$layout_name", 1.8);
        $output = elgg_view("canvas/layouts/$layout_name", $params);
    } elseif (elgg_view_exists("page/layouts/$layout_name")) {
        $output = elgg_view("page/layouts/$layout_name", $params);
    } else {
        $output = elgg_view("page/layouts/default", $params);
    }

    return elgg_trigger_plugin_hook('output:after', 'layout', $params, $output);
}

function elgg_view_menu($menu_name, array $vars = array()) {
    global $CONFIG;

    $vars['name'] = $menu_name;

    $sort_by = elgg_extract('sort_by', $vars, 'text');

    if (isset($CONFIG->menus[$menu_name])) {
        $menu = $CONFIG->menus[$menu_name];
    } else {
        $menu = array();
    }

    // Give plugins a chance to add menu items just before creation.
    // This supports dynamic menus (example: user_hover).
    $menu = elgg_trigger_plugin_hook('register', "menu:$menu_name", $vars, $menu);

    $builder = new ElggMenuBuilder($menu);
    $vars['menu'] = $builder->getMenu($sort_by);
    $vars['selected_item'] = $builder->getSelected();

    // Let plugins modify the menu
    $vars['menu'] = elgg_trigger_plugin_hook('prepare', "menu:$menu_name", $vars, $vars['menu']);

    if (elgg_view_exists("navigation/menu/$menu_name")) {
        return elgg_view("navigation/menu/$menu_name", $vars);
    } else {
        return elgg_view("navigation/menu/default", $vars);
    }
}

function elgg_view_entity(ElggEntity $entity, $vars = array(), $bypass = true, $debug = false) {

    // No point continuing if entity is null
    if (!$entity || !($entity instanceof ElggEntity)) {
        return false;
    }

    global $autofeed;
    $autofeed = true;

    $defaults = array(
        'full_view' => false,
    );

    if (is_array($vars)) {
        $vars = array_merge($defaults, $vars);
    } else {
        elgg_deprecated_notice("Update your use of elgg_view_entity()", 1.8);
        $vars = array(
            'full_view' => $vars,
        );
    }

    $vars['entity'] = $entity;


    // if this entity has a view defined, use it
    $view = $entity->view;
    if (is_string($view)) {
        return elgg_view($view, $vars, $bypass, $debug);
    }

    $entity_type = $entity->getType();

    $subtype = $entity->getSubtype();
    if (empty($subtype)) {
        $subtype = 'default';
    }

    $contents = '';
    if (elgg_view_exists("$entity_type/$subtype")) {
        $contents = elgg_view("$entity_type/$subtype", $vars, $bypass, $debug);
    }
    if (empty($contents)) {
        $contents = elgg_view("$entity_type/default", $vars, $bypass, $debug);
    }

    // Marcus Povey 20090616 : Speculative and low impact approach for fixing #964
    if ($vars['full_view']) {
        $annotations = elgg_view_entity_annotations($entity, $vars['full_view']);

        if ($annotations) {
            $contents .= $annotations;
        }
    }
    return $contents;
}

function elgg_view_entity_icon(ElggEntity $entity, $size = 'medium', $vars = array()) {

    // No point continuing if entity is null
    if (!$entity || !($entity instanceof ElggEntity)) {
        return false;
    }

    $vars['entity'] = $entity;
    $vars['size'] = $size;

    $entity_type = $entity->getType();

    $subtype = $entity->getSubtype();
    if (empty($subtype)) {
        $subtype = 'default';
    }

    $contents = '';
    if (elgg_view_exists("icon/$entity_type/$subtype")) {
        $contents = elgg_view("icon/$entity_type/$subtype", $vars);
    }
    if (empty($contents)) {
        $contents = elgg_view("icon/$entity_type/default", $vars);
    }
    if (empty($contents)) {
        $contents = elgg_view("icon/default", $vars);
    }

    return $contents;
}

function elgg_view_annotation(ElggAnnotation $annotation, array $vars = array(), $bypass = true, $debug = false) {
    global $autofeed;
    $autofeed = true;

    $defaults = array(
        'full_view' => true,
    );

    $vars = array_merge($defaults, $vars);
    $vars['annotation'] = $annotation;

    // @todo setting the view on an annotation is not advertised anywhere
    // do we want to keep this?
    $view = $annotation->view;
    if (is_string($view)) {
        return elgg_view($view, $vars, $bypass, $debug);
    }

    $name = $annotation->name;
    if (empty($name)) {
        return false;
    }

    if (elgg_view_exists("annotation/$name")) {
        return elgg_view("annotation/$name", $vars, $bypass, $debug);
    } else {
        return elgg_view("annotation/default", $vars, $bypass, $debug);
    }
}

function elgg_view_entity_list($entities, $vars = array(), $offset = 0, $limit = 10, $full_view = true,
$list_type_toggle = true, $pagination = true) {

    if (!is_int($offset)) {
        $offset = (int)get_input('offset', 0);
    }

    // list type can be passed as request parameter
    $list_type = get_input('list_type', 'list');
    if (get_input('listtype')) {
        elgg_deprecated_notice("'listtype' has been deprecated by 'list_type' for lists", 1.8);
        $list_type = get_input('listtype');
    }

    if (is_array($vars)) {
        // new function
        $defaults = array(
            'items' => $entities,
            'list_class' => 'elgg-list-entity',
            'full_view' => true,
            'pagination' => true,
            'list_type' => $list_type,
            'list_type_toggle' => false,
            'offset' => $offset,
        );

        $vars = array_merge($defaults, $vars);

    } else {
        // old function parameters
        elgg_deprecated_notice("Please update your use of elgg_view_entity_list()", 1.8);

        $vars = array(
            'items' => $entities,
            'count' => (int) $vars, // the old count parameter
            'offset' => $offset,
            'limit' => (int) $limit,
            'full_view' => $full_view,
            'pagination' => $pagination,
            'list_type' => $list_type,
            'list_type_toggle' => $list_type_toggle,
            'list_class' => 'elgg-list-entity',
        );
    }

    if ($vars['list_type'] != 'list') {
        return elgg_view('page/components/gallery', $vars);
    } else {
        return elgg_view('page/components/list', $vars);
    }
}

function elgg_view_annotation_list($annotations, array $vars = array()) {
    $defaults = array(
        'items' => $annotations,
        'list_class' => 'elgg-list-annotation elgg-annotation-list', // @todo remove elgg-annotation-list in Elgg 1.9
        'full_view' => true,
        'offset_key' => 'annoff',
    );

    $vars = array_merge($defaults, $vars);

    return elgg_view('page/components/list', $vars);
}

function elgg_view_entity_annotations(ElggEntity $entity, $full_view = true) {
    if (!($entity instanceof ElggEntity)) {
        return false;
    }

    $entity_type = $entity->getType();

    $annotations = elgg_trigger_plugin_hook('entity:annotate', $entity_type,
        array(
            'entity' => $entity,
            'full_view' => $full_view,
        )
    );

    return $annotations;
}

function elgg_view_title($title, $vars = array()) {
    if (!is_array($vars)) {
        elgg_deprecated_notice('setting $submenu in elgg_view_title() is deprecated', 1.8);
        $vars = array('submenu' => $vars);
    }

    $vars['title'] = $title;

    return elgg_view('page/elements/title', $vars);
}

function elgg_view_friendly_time($time) {
    return elgg_view('output/friendlytime', array('time' => $time));
}


function elgg_view_comments($entity, $add_comment = true, array $vars = array()) {
    if (!($entity instanceof ElggEntity)) {
        return false;
    }

    $vars['entity'] = $entity;
    $vars['show_add_form'] = $add_comment;
    $vars['class'] = elgg_extract('class', $vars, "{$entity->getSubtype()}-comments");

    $output = elgg_trigger_plugin_hook('comments', $entity->getType(), $vars, false);
    if ($output) {
        return $output;
    } else {
        return elgg_view('page/elements/comments', $vars);
    }
}

function elgg_view_image_block($image, $body, $vars = array()) {
    $vars['image'] = $image;
    $vars['body'] = $body;
    return elgg_view('page/components/image_block', $vars);
}

function elgg_view_module($type, $title, $body, array $vars = array()) {
    $vars['class'] = elgg_extract('class', $vars, '') . " elgg-module-$type";
    $vars['title'] = $title;
    $vars['body'] = $body;
    return elgg_view('page/components/module', $vars);
}

function elgg_view_river_item($item, array $vars = array()) {
    if (!($item instanceof ElggRiverItem)) {
        return '';
    }
    // checking default viewtype since some viewtypes do not have unique views per item (rss)
    $view = $item->getView();
    if (!$view || !elgg_view_exists($view, 'default')) {
        return '';
    }

    $subject = $item->getSubjectEntity();
    $object = $item->getObjectEntity();
    if (!$subject || !$object) {
        // subject is disabled or subject/object deleted
        return '';
    }

    // @todo this needs to be cleaned up
    // Don't hide objects in closed groups that a user can see.
    // see http://trac.elgg.org/ticket/4789
    //  else {
    //      // hide based on object's container
    //      $visibility = ElggGroupItemVisibility::factory($object->container_guid);
    //      if ($visibility->shouldHideItems) {
    //          return '';
    //      }
    //  }

    $vars['item'] = $item;

    return elgg_view('river/item', $vars);
}

function elgg_view_form($action, $form_vars = array(), $body_vars = array()) {
    global $CONFIG;

    $defaults = array(
        'action' => $CONFIG->wwwroot . "action/$action",
        'body' => elgg_view("forms/$action", $body_vars)
    );

    $form_class = 'elgg-form-' . preg_replace('/[^a-z0-9]/i', '-', $action);

    // append elgg-form class to any class options set
    if (isset($form_vars['class'])) {
        $form_vars['class'] = $form_vars['class'] . " $form_class";
    } else {
        $form_vars['class'] = $form_class;
    }

    return elgg_view('input/form', array_merge($defaults, $form_vars));
}

function elgg_view_list_item($item, array $vars = array()) {
    global $CONFIG;

    $type = $item->getType();
    if (in_array($type, $CONFIG->entity_types)) {
        return elgg_view_entity($item, $vars);
    } else if ($type == 'annotation') {
        return elgg_view_annotation($item, $vars);
    } else if ($type == 'river') {
        return elgg_view_river_item($item, $vars);
    }

    return '';
}

function elgg_view_icon($name, $class = '') {
    // @todo deprecate boolean in Elgg 1.9
    if ($class === true) {
        $class = 'float';
    }
    return "<span class=\"elgg-icon elgg-icon-$name $class\"></span>";
}

function elgg_view_access_collections($owner_guid) {
    if ($collections = get_user_access_collections($owner_guid)) {
        foreach ($collections as $key => $collection) {
            $collections[$key]->members = get_members_of_access_collection($collection->id, true);
            $collections[$key]->entities = get_user_friends($owner_guid, "", 9999);
        }
    }

    return elgg_view('core/friends/collections', array('collections' => $collections));
}

function set_template_handler($function_name) {
    global $CONFIG;

    if (is_callable($function_name)) {
        $CONFIG->template_handler = $function_name;
        return true;
    }
    return false;
}

function elgg_get_views($dir, $base) {
    $return = array();
    if (file_exists($dir) && is_dir($dir)) {
        if ($handle = opendir($dir)) {
            while ($view = readdir($handle)) {
                if (!in_array($view, array('.', '..', '.svn', 'CVS'))) {
                    if (is_dir($dir . '/' . $view)) {
                        if ($val = elgg_get_views($dir . '/' . $view, $base . '/' . $view)) {
                            $return = array_merge($return, $val);
                        }
                    } else {
                        $view = str_replace('.php', '', $view);
                        $return[] = $base . '/' . $view;
                    }
                }
            }
        }
    }

    return $return;
}

function elgg_view_tree($view_root, $viewtype = "") {
    global $CONFIG;
    static $treecache = array();

    // Get viewtype
    if (!$viewtype) {
        $viewtype = elgg_get_viewtype();
    }

    // A little light internal caching
    if (!empty($treecache[$view_root])) {
        return $treecache[$view_root];
    }

    // Examine $CONFIG->views->locations
    if (isset($CONFIG->views->locations[$viewtype])) {
        foreach ($CONFIG->views->locations[$viewtype] as $view => $path) {
            $pos = strpos($view, $view_root);
            if ($pos === 0) {
                $treecache[$view_root][] = $view;
            }
        }
    }

    // Now examine core
    $location = $CONFIG->viewpath;
    $viewtype = elgg_get_viewtype();
    $root = $location . $viewtype . '/' . $view_root;

    if (file_exists($root) && is_dir($root)) {
        $val = elgg_get_views($root, $view_root);
        if (!is_array($treecache[$view_root])) {
            $treecache[$view_root] = array();
        }
        $treecache[$view_root] = array_merge($treecache[$view_root], $val);
    }

    return $treecache[$view_root];
}

function autoregister_views($view_base, $folder, $base_location_path, $viewtype) {
    if ($handle = opendir($folder)) {
        while ($view = readdir($handle)) {
            if (!in_array($view, array('.', '..', '.svn', 'CVS')) && !is_dir($folder . "/" . $view)) {
                // this includes png files because some icons are stored within view directories.
                // See commit [1705]
                if ((substr_count($view, ".php") > 0) || (substr_count($view, ".png") > 0)) {
                    if (!empty($view_base)) {
                        $view_base_new = $view_base . "/";
                    } else {
                        $view_base_new = "";
                    }

                    elgg_set_view_location($view_base_new . str_replace('.php', '', $view),
                        $base_location_path, $viewtype);
                }
            } else if (!in_array($view, array('.', '..', '.svn', 'CVS')) && is_dir($folder . "/" . $view)) {
                if (!empty($view_base)) {
                    $view_base_new = $view_base . "/";
                } else {
                    $view_base_new = "";
                }
                autoregister_views($view_base_new . $view, $folder . "/" . $view,
                    $base_location_path, $viewtype);
            }
        }
        return TRUE;
    }

    return FALSE;
}

function elgg_views_add_rss_link() {
    global $autofeed;
    if (isset($autofeed) && $autofeed == true) {
        $url = full_url();
        if (substr_count($url, '?')) {
            $url .= "&view=rss";
        } else {
            $url .= "?view=rss";
        }

        $url = elgg_format_url($url);
        elgg_register_menu_item('extras', array(
            'name' => 'rss',
            'text' => elgg_view_icon('rss'),
            'href' => $url,
            'title' => elgg_echo('feed:rss'),
        ));
    }
}

function elgg_views_handle_deprecated_views() {
    $location = elgg_get_view_location('page_elements/contentwrapper');
    if ($location === "/var/www/views/") {
        elgg_extend_view('page_elements/contentwrapper', 'page/elements/wrapper');
    }
}

function elgg_views_boot() {
    global $CONFIG;

    elgg_register_simplecache_view('css/ie');
    elgg_register_simplecache_view('css/ie6');
    elgg_register_simplecache_view('css/ie7');

    elgg_register_js('jquery', '/vendors/jquery/jquery-1.6.4.min.js', 'head');
    elgg_register_js('jquery-ui', '/vendors/jquery/jquery-ui-1.8.16.min.js', 'head');
    elgg_register_js('jquery.form', '/vendors/jquery/jquery.form.js');

    elgg_register_simplecache_view('js/elgg');
    $elgg_js_url = elgg_get_simplecache_url('js', 'elgg');
    elgg_register_js('elgg', $elgg_js_url, 'head');

    elgg_load_js('jquery');
    elgg_load_js('jquery-ui');
    elgg_load_js('elgg');

    elgg_register_simplecache_view('js/lightbox');
    $lightbox_js_url = elgg_get_simplecache_url('js', 'lightbox');
    elgg_register_js('lightbox', $lightbox_js_url);

    elgg_register_simplecache_view('css/lightbox');
    $lightbox_css_url = elgg_get_simplecache_url('css', 'lightbox');
    elgg_register_css('lightbox', $lightbox_css_url);

    elgg_register_simplecache_view('css/elgg');
    $elgg_css_url = elgg_get_simplecache_url('css', 'elgg');
    elgg_register_css('elgg', $elgg_css_url);

    elgg_load_css('elgg');

    elgg_register_ajax_view('js/languages');

    elgg_register_plugin_hook_handler('output:before', 'layout', 'elgg_views_add_rss_link');

    // discover the built-in view types
    // @todo the cache is loaded in load_plugins() but we need to know view_types earlier
    $view_path = $CONFIG->viewpath;

    $views = scandir($view_path);

    foreach ($views as $view) {
        if ($view[0] !== '.' && is_dir($view_path . $view)) {
            elgg_register_viewtype($view);
        }
    }

    // set default icon sizes - can be overridden in settings.php or with plugin
    if (!$CONFIG->icon_sizes) {
        $icon_sizes = array(
            'topbar' => array('w' => 16, 'h' => 16, 'square' => TRUE, 'upscale' => TRUE),
            'tiny' => array('w' => 25, 'h' => 25, 'square' => TRUE, 'upscale' => TRUE),
            'small' => array('w' => 40, 'h' => 40, 'square' => TRUE, 'upscale' => TRUE),
            'medium' => array('w' => 100, 'h' => 100, 'square' => TRUE, 'upscale' => TRUE),
            'large' => array('w' => 200, 'h' => 200, 'square' => FALSE, 'upscale' => FALSE),
            'master' => array('w' => 550, 'h' => 550, 'square' => FALSE, 'upscale' => FALSE),
        );
        elgg_set_config('icon_sizes', $icon_sizes);
    }
}

elgg_register_event_handler('boot', 'system', 'elgg_views_boot');
elgg_register_event_handler('init', 'system', 'elgg_views_handle_deprecated_views');

---