view Class Reference
[Objects that represent a View or part of a view.]

Inheritance diagram for view:

List of all members.

---

Detailed Description

An object to contain all of the data to generate a view, plus the member functions to build the view query, execute the query and render the output.

Definition at line 19 of file view.inc.

Public Member Functions
	view ()
	Constructor.
	display_objects ()
	Returns a list of the sub-object types used by this view.
	db_objects ()
	Returns the complete list of dependent objects in a view, for the purpose of initialization and loading/saving to/from the database.
	set_arguments ($args)
	Set the arguments that come to this view.
	set_items_per_page ($items_per_page)
	Set the page size for ranged or pager queries.
	set_current_page ($page)
	Change/Set the current page for the pager.
	set_use_pager ($use_pager)
	Whether or not the pager should be used.
	set_pager_element ($pager_element)
	The pager element id to use if use_apger is on.
	set_offset ($offset)
	How many records to skip.
	set_use_ajax ($use_ajax)
	Whether or not AJAX should be used.
	set_exposed_input ($filters)
	Set the exposed filters input to an array.
	get_exposed_input ()
	Figure out what the exposed input for this view is.
	init_display ($reset=FALSE)
	Set the display for this view and initialize the display handler.
	choose_display ($displays)
	Get the first display that is accessible to the user.
	set_display ($display_id=NULL)
	Set the display as current.
	init_style ()
	Find and initialize the style plugin.
	init_handlers ()
	Acquire and attach all of the handlers.
	get_base_tables ()
	Create a list of base tables eligible for this view.
	_pre_query ()
	Run the pre_query() on all active handlers.
	_init_handler ($key, $info)
	Attach all of the handlers for each type.
	render_exposed_form ($block=FALSE)
	Render the exposed filter form.
	_build_arguments ()
	Build all the arguments.
	init_query ()
	Do some common building initialization.
	build ($display_id=NULL)
	Build the query for the view.
	_build ($key)
	Internal method to build an individual set of handlers.
	execute ($display_id=NULL)
	Execute the view's query.
	render ($display_id=NULL)
	Render this view for display.
	render_field ($field, $row)
	Render a specific field via the field ID and the row #.
	execute_display ($display_id=NULL, $args=array())
	Execute the given display, with the given arguments.
	preview ($display_id=NULL, $args=array())
	Preview the given display, with the given arguments.
	pre_execute ($args=array())
	Run attachments and let the display do what it needs to do prior to running.
	post_execute ()
	Unset the current view, mostly.
	attach_displays ()
	Run attachment displays for the view.
	execute_hook_menu ($display_id=NULL)
	Called to get hook_menu information from the view and the named display handler.
	execute_hook_block ($display_id=NULL)
	Called to get hook_block information from the view and the named display handler.
	access ($displays=NULL, $account=NULL)
	Determine if the given user has access to the view.
	get_title ()
	Get the view's current title.
	build_title ()
	Force the view to build a title.
	get_url ($args=NULL, $path=NULL)
	Get the URL for the current view.
	get_path ()
	Get the base path used for this view.
	get_breadcrumb ($set=FALSE)
	Get the breadcrumb used for this view.
	is_cacheable ()
	Is this view cacheable?
	start_query_capture ()
	Set up query capturing.
	end_query_capture ()
	Add the list of queries run during render to buildinfo.
&	load ($arg, $reset=FALSE)
	Load a view from the database based upon either vid or name.
	load_views ()
	Static factory method to load a list of views based upon a $where clause.
	save ()
	Save the view to the database.
	_save_rows ($key)
	Save a row to the database for the given key, which is one of the keys from view::db_objects().
	delete ()
	Delete the view from the database.
	export ($indent= '')
	Export a view as PHP code.
	copy ()
	Make a copy of this view that has been sanitized of all database IDs and handlers and other stuff.
	clone_view ()
	Safely clone a view.
	destroy ()
	Unset references so that a $view object may be properly garbage collected.
	validate ()
	Make sure the view is completely valid.
	init ($init=TRUE)
	Initialize this object, setting values from schema defaults.
	save_row ($update=NULL)
	Write the row to the database.
	load_row ($data)
	Load the object with a row from the database.
	export_row ($identifier=NULL, $indent= '')
	Export a loaded row, such as an argument, field or the view itself to PHP code.
	add_display ($type= 'page', $title=NULL, $id=NULL)
	Add a new display handler to the view, automatically creating an id.
&	new_display ($type= 'page', $title=NULL, $id=NULL)
	Create a new display and a display handler for it.
	add_item ($display_id, $type, $table, $field, $options=array(), $id=NULL)
	Add an item with a handler to the view.
	get_items ($type, $display_id=NULL)
	Get an array of items for the current display.
	get_item ($display_id, $type, $id)
	Get the configuration of an item (field/sort/filter/etc) on a given display.
	set_item ($display_id, $type, $id, $item)
	Get the configuration of an item (field/sort/filter/etc) on a given display.
	set_item_option ($display_id, $type, $id, $option, $value)
	Set an option on an item.
Public Attributes
	$db_table = 'views_view'
	$base_table = 'node'
	$built = FALSE
	$executed = FALSE
	$args = array()
	$build_info = array()
	$use_ajax = FALSE
	$result = array()
	$pager
	$attachment_before = ''
	$attachment_after = ''
	$exposed_data = array()
	$exposed_input = array()
	$old_view = array()

---

Member Function Documentation

view::_build

(

$

key

)

Internal method to build an individual set of handlers.

Definition at line 657 of file view.inc.

Referenced by build().

                        {
    $handlers = &$this->$key;
    foreach ($handlers as $id => $data) {
      if (!empty($handlers[$id]) && is_object($handlers[$id])) {
        // Give this handler access to the exposed filter input.
        if (!empty($this->exposed_data)) {
          $rc = $handlers[$id]->accept_exposed_input($this->exposed_data);
          $handlers[$id]->store_exposed_input($this->exposed_data, $rc);
          if (!$rc) {
            continue;
          }
        }
        $handlers[$id]->set_relationship();
        $handlers[$id]->query();
      }
    }
  }

view::_build_arguments

(

)

Build all the arguments.

Definition at line 424 of file view.inc.

References $title, and get_url().

Referenced by build(), and build_title().

                              {
    // Initially, we want to build sorts and fields. This can change, though,
    // if we get a summary view.
    if (empty($this->argument)) {
      return TRUE;
    }

    // build arguments.
    $position = -1;

    // Create a title for use in the breadcrumb trail.
    $title = $this->display_handler->get_option('title');

    $this->build_info['breadcrumb'] = array();
    $breadcrumb_args = array();
    $substitutions = array();

    $status = TRUE;

    // Iterate through each argument and process.
    foreach ($this->argument as $id => $arg) {
      $position++;
      $argument = &$this->argument[$id];

      if ($argument->broken()) {
        continue;
      }

      $argument->set_relationship();

      $arg = isset($this->args[$position]) ? $this->args[$position] : NULL;
      $argument->position = $position;

      if (isset($arg) || $argument->has_default_argument()) {
        if (!isset($arg)) {
          $arg = $argument->get_default_argument();
          // make sure default args get put back.
          if (isset($arg)) {
            $this->args[$position] = $arg;
          }
        }

        // Set the argument, which will also validate that the argument can be set.
        if (!$argument->set_argument($arg)) {
          $status = $argument->validate_fail($arg);
          break;
        }

        if ($argument->is_wildcard()) {
          $arg_title = $argument->wildcard_title();
        }
        else {
          $arg_title = $argument->get_title();
          $argument->query();
        }

        // Add this argument's substitution
        $substitutions['%' . ($position + 1)] = $arg_title;

        // Since we're really generating the breadcrumb for the item above us,
        // check the default action of this argument.
        if ($this->display_handler->uses_breadcrumb() && $argument->uses_breadcrumb()) {
          $path = $this->get_url($breadcrumb_args);
          if (strpos($path, '%') === FALSE) {
            $breadcrumb = !empty($argument->options['breadcrumb'])? $argument->options['breadcrumb'] : $title;
            $this->build_info['breadcrumb'][$path] = str_replace(array_keys($substitutions), $substitutions, $breadcrumb);
          }
        }

        // Allow the argument to muck with this breadcrumb.
        $argument->set_breadcrumb($this->build_info['breadcrumb']);

        // Test to see if we should use this argument's title
        if (!empty($argument->options['title'])) {
          $title = $argument->options['title'];
        }

        $breadcrumb_args[] = $arg;
      }
      else {
        // determine default condition and handle.
        $status = $argument->default_action();
        break;
      }

      // Be safe with references and loops:
      unset($argument);
    }

    // set the title in the build info.
    if (!empty($title)) {
      $this->build_info['title'] = str_replace(array_keys($substitutions), $substitutions, $title);
    }

    // Store the arguments for later use.
    $this->build_info['substitutions'] = $substitutions;

    return $status;
  }

view::_init_handler	(	$	key,
		$	info
	)

Attach all of the handlers for each type.

Parameters:

	$key	One of 'argument', 'field', 'sort', 'filter', 'relationship'
	$info	The $info from views_object_types for this object.

Definition at line 370 of file view.inc.

References access().

Referenced by init_handlers().

                                      {
    // Load the requested items from the display onto the object.
    $this->$key = $this->display_handler->get_handlers($key);

    // This reference deals with difficult PHP indirection.
    $handlers = &$this->$key;

    // Run through and test for accessibility.
    foreach ($handlers as $id => $handler) {
      if (!$handler->access()) {
        unset($handlers[$id]);
      }
    }
  }

view::_pre_query

(

)

Run the pre_query() on all active handlers.

Definition at line 350 of file view.inc.

References views_object_types().

Referenced by build().

                        {
    foreach (views_object_types() as $key => $info) {
      $handlers = &$this->$key;
      $position = 0;
      foreach ($handlers as $id => $handler) {
        $handlers[$id]->position = $position;
        $handlers[$id]->pre_query();
        $position++;
      }
    }
  }

view::_save_rows

(

$

key

)

Save a row to the database for the given key, which is one of the keys from view::db_objects().

Definition at line 1414 of file view.inc.

Referenced by save().

                            {
    $count = 0;
    foreach ($this->$key as $position => $object) {
      $object->position = ++$count;
      $object->vid = $this->vid;
      $object->save_row();
    }
  }

view::access	(	$	displays = NULL,
		$	account = NULL
	)

Determine if the given user has access to the view.

Note that this sets the display handler if it hasn't been.

Definition at line 1048 of file view.inc.

References $display_id, and init_display().

Referenced by _init_handler().

                                                     {
    if (!isset($this->current_display)) {
      $this->init_display();
    }

    if (!$account) {
      $account = $GLOBALS['user'];
    }

    // We can't use choose_display() here because that function
    // calls this one.
    $displays = (array)$displays;
    foreach ($displays as $display_id) {
      if (!empty($this->display[$display_id]->handler)) {
        if ($this->display[$display_id]->handler->access($account)) {
          return TRUE;
        }
      }
    }

    return FALSE;
  }

views_db_object::add_display	(	$	type = 'page',
		$	title = NULL,
		$	id = NULL
	)			[inherited]

Add a new display handler to the view, automatically creating an id.

Parameters:

	$type	The plugin type from the views plugin data. Defaults to 'page'.
	$title	The title of the display; optional, may be filled in from default.
	$id	The id to use.

Returns:

The key to the display in $view->display, so that the new display can be easily located.

Definition at line 1795 of file view.inc.

References $title.

Referenced by views_db_object::new_display().

                                                                  {
    if (empty($type)) {
      return FALSE;
    }

    $plugin = views_fetch_plugin_data('display', $type);
    if (empty($plugin)) {
      $plugin['title'] = t('Broken');
    }

    // 'default' is singular and is unique, so just go with 'default'
    // for it. For all others, start counting.
    if (empty($id)) {
      $id = ($type == 'default') ? $type : $type . '_1';
      $title = $plugin['title'];

      $count = 1;

      // Loop through IDs based upon our style plugin name until
      // we find one that is unused.
      while (!empty($this->display[$id])) {
        $id = $type . '_' . ++$count;
        if (empty($title)) {
          $title = $plugin['title'] . ' ' . $count;
        }
      }
    }

    // Create the new display object
    $display = new views_display;
    $display->options($type, $id, $title);

    // Add the new display object to the view.
    $this->display[$id] = $display;
    return $id;
  }

views_db_object::add_item	(	$	display_id,
		$	type,
		$	table,
		$	field,
		$	options = array(),
		$	id = NULL
	)			[inherited]

Add an item with a handler to the view.

These items may be fields, filters, sort criteria, or arguments.

Definition at line 1871 of file view.inc.

References $display_id, $field, and views_object_types().

                                                                                        {
    $types = views_object_types();
    $this->set_display($display_id);

    $fields = $this->display[$display_id]->handler->get_option($types[$type]['plural']);

    if (empty($id)) {
      $count = 0;
      $id = $field;
      while (!empty($fields[$id])) {
        $id = $field . '_' . ++$count;
      }
    }

    $new_item = array(
      'id' => $id,
      'table' => $table,
      'field' => $field,
    ) + $options;

    $handler = views_get_handler($table, $field, $type);

    $fields[$id] = $new_item;
    $this->display[$display_id]->handler->set_option($types[$type]['plural'], $fields);

    return $id;
  }

view::attach_displays

(

)

Run attachment displays for the view.

Definition at line 989 of file view.inc.

Referenced by build().

                             {
    if (!empty($this->is_attachment)) {
      return;
    }

    if (!$this->display_handler->accept_attachments()) {
      return;
    }

    $this->is_attachment = TRUE;
    // Give other displays an opportunity to attach to the view.
    foreach ($this->display as $id => $display) {
      if (!empty($this->display[$id]->handler)) {
        $this->display[$id]->handler->attach_to($this->current_display);
      }
    }
    $this->is_attachment = FALSE;
  }

view::build

(

$

display_id = NULL

)

Build the query for the view.

Definition at line 541 of file view.inc.

References $display_id, _build(), _build_arguments(), _pre_query(), attach_displays(), init_handlers(), init_query(), init_style(), render_exposed_form(), and set_display().

Referenced by execute().

                                     {
    if (!empty($this->built)) {
      return;
    }

    if (empty($this->current_display) || $display_id) {
      if (!$this->set_display($display_id)) {
        return FALSE;
      }
    }

    // Let modules modify the view just prior to executing it.
    foreach (module_implements('views_pre_build') as $module) {
      $function = $module . '_views_pre_build';
      $function($this);
    }

    // Attempt to load from cache.
    // @todo Load a build_info from cache.

    $start = views_microtime();
    // If that fails, let's build!
    $this->build_info = array(
      'query' => '',
      'count_query' => '',
      'query_args' => array(),
    );

    $this->init_query();

    // Call a module hook and see if it wants to present us with a
    // pre-built query or instruct us not to build the query for
    // some reason.
    // @todo: Implement this. Use the same mechanism Panels uses.

    // Run through our handlers and ensure they have necessary information.
    $this->init_handlers();

    // Let the handlers interact with each other if they really want.
    $this->_pre_query();

    if ($this->display_handler->uses_exposed()) {
      $this->exposed_widgets = $this->render_exposed_form();
      if (form_set_error() || !empty($this->build_info['abort'])) {
        $this->built = TRUE;
        return empty($this->build_info['fail']);
      }
    }

    // Build all the relationships first thing.
    $this->_build('relationship');

    // Build all the filters.
    $this->_build('filter');

    $this->build_sort = TRUE;

    // Arguments can, in fact, cause this whole thing to abort.
    if (!$this->_build_arguments()) {
      $this->build_time = views_microtime() - $start;
      $this->attach_displays();
      return $this->built;
    }

    // Initialize the style; arguments may have changed which style we use,
    // so waiting as long as possible is important. But we need to know
    // about the style when we go to build fields.
    if (!$this->init_style()) {
      $this->build_info['fail'] = TRUE;
      return FALSE;
    }

    if ($this->style_plugin->uses_fields()) {
      $this->_build('field');
    }

    // Build our sort criteria if we were instructed to do so.
    if (!empty($this->build_sort)) {
      // Allow the style handler to deal with sorting.
      if ($this->style_plugin->build_sort()) {
        $this->_build('sort');
      }
      // allow the plugin to build second sorts as well.
      $this->style_plugin->build_sort_post();
    }

    // Allow display handler to affect the query:
    $this->display_handler->query();

    // Allow style handler to affect the query:
    $this->style_plugin->query();

    if (variable_get('views_sql_signature', FALSE)) {
      $this->query->add_field(NULL, "'" . $this->name . ':' . $this->current_display . "'", 'view_name');
    }

    // Let modules modify the query just prior to finalizing it.
    foreach (module_implements('views_query_alter') as $module) {
      $function = $module . '_views_query_alter';
      $function($this, $this->query);
    }

    $this->build_info['query'] = $this->query->query();
    $this->build_info['count_query'] = $this->query->query(TRUE);
    $this->build_info['query_args'] = $this->query->get_where_args();
    $this->built = TRUE;
    $this->build_time = views_microtime() - $start;

    // Attach displays
    $this->attach_displays();
    return TRUE;
  }

view::build_title

(

)

Force the view to build a title.

Definition at line 1096 of file view.inc.

References _build_arguments(), init_display(), init_handlers(), and init_query().

                         {
    $this->init_display();
    if (empty($this->built)) {
      $this->init_query();
    }
    $this->init_handlers();

    $this->_build_arguments();
  }

view::choose_display

(

$

displays

)

Get the first display that is accessible to the user.

Parameters:

$displays

Either a single display id or an array of display ids.

Definition at line 228 of file view.inc.

References $display_id, and init_display().

Referenced by execute_display(), and set_display().

                                     {
    if (!is_array($displays)) {
      return $displays;
    }

    $this->init_display();

    foreach ($displays as $display_id) {
      if ($this->display[$display_id]->handler->access()) {
        return $display_id;
      }
    }

    return 'default';
  }

view::clone_view

(

)

Safely clone a view.

Because views are complicated objects within objects, and PHP loves to do references to everything, if a View is not properly and safely cloned it will still have references to the original view, and can actually cause the original view to point to objects in the cloned view. This gets ugly fast.

This will completely wipe a view clean so it can be considered fresh.

Definition at line 1512 of file view.inc.

                        {
    $clone = version_compare(phpversion(), '5.0') < 0 ? $this : clone($this);

    $keys = array('current_display', 'display_handler', 'build_info', 'built', 'executed', 'attachment_before', 'attachment_after', 'field', 'argument', 'filter', 'sort', 'relationship', 'query', 'inited', 'style_plugin', 'plugin_name', 'exposed_data', 'exposed_input', 'exposed_widgets', 'many_to_one_tables');
    foreach ($keys as $key) {
      if (isset($clone->$key)) {
        unset($clone->$key);
      }
    }
    $clone->built = $clone->executed = FALSE;
    $clone->build_info = array();
    $clone->attachment_before = '';
    $clone->attachment_after = '';
    $clone->result = array();

    // shallow cloning means that all the display objects
    // *were not cloned*. We must clone them ourselves.
    $displays = array();
    foreach ($clone->display as $id => $display) {
      $displays[$id] = drupal_clone($display);
      if (isset($displays[$id]->handler)) {
        unset($displays[$id]->handler);
      }
    }
    $clone->display = $displays;

    return $clone;
  }

view::copy

(

)

Make a copy of this view that has been sanitized of all database IDs and handlers and other stuff.

I'd call this clone() but it's reserved.

Definition at line 1495 of file view.inc.

References export().

                  {
    $code = $this->export();
    eval($code);
    return $view;
  }

view::db_objects

(

)

Returns the complete list of dependent objects in a view, for the purpose of initialization and loading/saving to/from the database.

Note: In PHP5 this should be static, but PHP4 doesn't support static methods.

Definition at line 82 of file view.inc.

Referenced by delete(), load(), load_views(), save(), and view().

                        {
    return array('display');
  }

view::delete

(

)

Delete the view from the database.

Definition at line 1426 of file view.inc.

References db_objects().

                    {
    if (empty($this->vid)) {
      return;
    }

    db_query("DELETE FROM {views_view} WHERE vid = %d", $this->vid);
    // Delete from all of our subtables as well.
    foreach ($this->db_objects() as $key) {
      db_query("DELETE from {views_" . $key . "} WHERE vid = %d", $this->vid);
    }

    cache_clear_all('views_query:' . $this->name, 'cache_views');
    cache_clear_all(); // In Drupal 5.0 and later this clears the page cache only.
    menu_rebuild(); // force a menu rebuild when a view is deleted.
  }

view::destroy

(

)

Unset references so that a $view object may be properly garbage collected.

Definition at line 1545 of file view.inc.

References $display_id, $item, and views_object_types().

                     {
    foreach (array_keys($this->display) as $display_id) {
      if (isset($this->display[$display_id]->handler)) {
        $this->display[$display_id]->handler->destroy();
        unset($this->display[$display_id]->handler);
      }

      foreach (views_object_types() as $type => $info) {
        if (isset($this->$type)) {
          $handlers = &$this->$type;
          foreach ($handlers as $id => $item) {
            $handlers[$id]->destroy();
          }
          unset($handlers);
        }
      }

      if (isset($this->style_plugin)) {
        $this->style_plugin->destroy();
        unset($this->style_plugin);
      }

      // Clear these to make sure the view can be processed/used again.
      if (isset($this->display_handler)) {
        unset($this->display_handler);
      }

      if (isset($this->current_display)) {
        unset($this->current_display);
      }

      if (isset($this->query)) {
        unset($this->query);
      }
    }
  }

view::display_objects

(

)

Returns a list of the sub-object types used by this view.

These types are stored on the display, and are used in the build process.

Definition at line 71 of file view.inc.

                             {
    return array('argument', 'field', 'sort', 'filter', 'relationship');
  }

view::end_query_capture

(

)

Add the list of queries run during render to buildinfo.

See also:

view::start_query_capture()

Definition at line 1246 of file view.inc.

Referenced by render().

                               {
    global $conf, $queries;
    if (!empty($this->fix_dev_query)) {
      $conf['dev_query'] = FALSE;
    }

    // make a copy of the array so we can manipulate it with array_splice.
    $temp = $queries;

    // Scroll through the queries until we get to our last query key.
    // Unset anything in our temp array.
    if (isset($this->last_query_key)) {
      while (list($id, $query) = each($queries)) {
        if ($id == $this->last_query_key) {
          break;
        }

        unset($temp[$id]);
      }
    }

    $this->additional_queries = $temp;
  }

view::execute

(

$

display_id = NULL

)

Execute the view's query.

Definition at line 678 of file view.inc.

References $args, $display_id, $item, $items, $result, and build().

Referenced by render().

                                       {
    if (empty($this->built)) {
      if (!$this->build($display_id)) {
        return FALSE;
      }
    }

    if (!empty($this->executed)) {
      return TRUE;
    }

    // Let modules modify the view just prior to executing it.
    foreach (module_implements('views_pre_execute') as $module) {
      $function = $module . '_views_pre_execute';
      $function($this);
    }

    $query = db_rewrite_sql($this->build_info['query'], $this->base_table, $this->base_field, array('view' => &$this));
    $count_query = db_rewrite_sql($this->build_info['count_query'], $this->base_table, $this->base_field, array('view' => &$this));

    $args = $this->build_info['query_args'];

    vpr($query);


    // Check for already-cached results.
    if (!empty($this->live_preview)) {
      $cache = FALSE;
    }
    else {
      $cache = $this->display_handler->get_cache_plugin();
    }
    if ($cache && $cache->cache_get('results')) {
      vpr('Used cached results');
    }
    else {
      $items = array();
      if ($query) {
        $replacements = module_invoke_all('views_query_substitutions', $this);
        $query = str_replace(array_keys($replacements), $replacements, $query);
        $count_query = 'SELECT COUNT(*) FROM (' . str_replace(array_keys($replacements), $replacements, $count_query) . ') count_alias';

        if (is_array($args)) {
          foreach ($args as $id => $arg) {
            $args[$id] = str_replace(array_keys($replacements), $replacements, $arg);
          }
        }

        // Allow for a view to query an external database.
        if (isset($this->base_database)) {
          db_set_active($this->base_database);
          $external = TRUE;
        }

        $start = views_microtime();
        if (!empty($this->pager['items_per_page'])) {
          // We no longer use pager_query() here because pager_query() does not
          // support an offset. This is fine as we don't actually need pager
          // query; we've already been doing most of what it does, and we
          // just need to do a little more playing with globals.
          if (!empty($this->pager['use_pager']) || !empty($this->get_total_rows)) {
            $this->total_rows = db_result(db_query($count_query, $args)) - $this->pager['offset'];
          }

          if (!empty($this->pager['use_pager'])) {
            // dump information about what we already know into the globals
            global $pager_page_array, $pager_total, $pager_total_items;
            // total rows in query
            $pager_total_items[$this->pager['element']] = $this->total_rows;
            // total pages
            $pager_total[$this->pager['element']] = ceil($pager_total_items[$this->pager['element']] / $this->pager['items_per_page']);

            // What page was requested:
            $pager_page_array = isset($_GET['page']) ? explode(',', $_GET['page']) : array();

            // If the requested page was within range. $this->pager['current_page']
            // defaults to 0 so we don't need to set it in an out-of-range condition.
            if (!empty($pager_page_array[$this->pager['element']])) {
              $page = intval($pager_page_array[$this->pager['element']]);
              if ($page > 0 && $page < $pager_total[$this->pager['element']]) {
                $this->pager['current_page'] = $page;
              }
            }
            $pager_page_array[$this->pager['element']] = $this->pager['current_page'];
          }

          $offset = $this->pager['current_page'] * $this->pager['items_per_page'] + $this->pager['offset'];
          $result = db_query_range($query, $args, $offset, $this->pager['items_per_page']);

        }
        else {
          $result = db_query($query, $args);
        }

        $this->result = array();
        while ($item = db_fetch_object($result)) {
          $this->result[] = $item;
        }

        // If we already know how many items we have even if we did not run the
        // count query, go ahead and set that value:
        if (empty($this->pager['items_per_page'])) {
          $this->total_rows = count($this->result);
        }

        if (!empty($external)) {
          db_set_active();
        }
        $this->execute_time = views_microtime() - $start;
      }
      if ($cache) {
        $cache->cache_set('results');
      }
    }

    $this->executed = TRUE;
  }

view::execute_display	(	$	display_id = NULL,
		$	args = array()
	)

Execute the given display, with the given arguments.

To be called externally by whatever mechanism invokes the view, such as a page callback, hook_block, etc.

This function should NOT be used by anything external as this returns data in the format specified by the display. It can also have other side effects that are only intended for the 'proper' use of the display, such as setting page titles and breadcrumbs.

If you simply want to view the display, use view::preview() instead.

Definition at line 906 of file view.inc.

References $args, $display_id, choose_display(), post_execute(), pre_execute(), and set_display().

                                                                {
    if (empty($this->current_display) || $this->current_display != $this->choose_display($display_id)) {
      if (!$this->set_display($display_id)) {
        return FALSE;
      }
    }

    $this->pre_execute($args);

    // Execute the view
    $output = $this->display_handler->execute();

    $this->post_execute();
    return $output;
  }

view::execute_hook_block

(

$

display_id = NULL

)

Called to get hook_block information from the view and the named display handler.

Definition at line 1030 of file view.inc.

References $display_id, and set_display().

                                                  {
    // Prepare the view with the information we have.

    // This was probably already called, but it's good to be safe.
    if (!$this->set_display($display_id)) {
      return FALSE;
    }

    // Execute the view
    if (isset($this->display_handler)) {
      return $this->display_handler->execute_hook_block();
    }
  }

view::execute_hook_menu

(

$

display_id = NULL

)

Called to get hook_menu information from the view and the named display handler.

Definition at line 1012 of file view.inc.

References $display_id, and set_display().

                                                 {
    // Prepare the view with the information we have.

    // This was probably already called, but it's good to be safe.
    if (!$this->set_display($display_id)) {
      return FALSE;
    }

    // Execute the view
    if (isset($this->display_handler)) {
      return $this->display_handler->execute_hook_menu();
    }
  }

view::export

(

$

indent = ''

)

Export a view as PHP code.

Definition at line 1445 of file view.inc.

References views_db_object::export_row(), and init_display().

Referenced by copy().

                                {
    $this->init_display();
    $output = '';
    $output .= $this->export_row('view', $indent);
    // Set the API version
    $output .= $indent . '$view->api_version = 2' . ";\n";
    $output .= $indent . '$view->disabled = FALSE; /* Edit this to true to make a default view disabled initially */' . "\n";

    foreach ($this->display as $id => $display) {
      $output .= $indent . '$handler = $view->new_display(' . views_var_export($display->display_plugin, $indent) . ', ' . views_var_export($display->display_title, $indent) . ', \'' . $id . "');\n";
      if (empty($display->handler)) {
        // @todo -- probably need a method of exporting broken displays as
        // they may simply be broken because a module is not installed. That
        // does not invalidate the display.
        continue;
      }

      foreach ($display->handler->option_definition() as $option => $definition) {
        // Special handling for some items
        switch ($option) {
          case 'defaults':
            // skip these
            break;
          default:
            if (!$display->handler->is_defaulted($option)) {
              $value = $display->handler->get_option($option);
              if ($id == 'default') {
                $default = isset($definition['default']) ? $definition['default'] : NULL;
              }
              else {
                $default = $this->display['default']->handler->get_option($option);
              }

              if ($value !== $default) {
                $output .= $indent . '$handler->override_option(\'' . $option . '\', ' . views_var_export($value, $indent) . ");\n";
              }
            }
        }
      }
    }

    return $output;
  }

views_db_object::export_row	(	$	identifier = NULL,
		$	indent = ''
	)			[inherited]

Export a loaded row, such as an argument, field or the view itself to PHP code.

Parameters:

	$identifier	The variable to assign the PHP code for this object to.
	$indent	An optional indentation for prettifying nested code.

Definition at line 1747 of file view.inc.

References $field.

Referenced by export().

                                                        {
    if (!$identifier) {
      $identifier = $this->db_table;
    }
    $schema = drupal_get_schema($this->db_table);

    $output = $indent . '$' . $identifier . ' = new ' . get_class($this) . ";\n";
    // Go through our schema and build correlations.
    foreach ($schema['fields'] as $field => $info) {
      if (!empty($info['no export'])) {
        continue;
      }
      if (!isset($this->$field)) {
        if (isset($info['default'])) {
          $this->$field = $info['default'];
        }
        else {
          $this->$field = '';
        }

        // serialized defaults must be set as serialized.
        if (isset($info['serialize'])) {
          $this->$field = unserialize(db_decode_blob($this->$field));
        }
      }
      $value = $this->$field;
      if ($info['type'] == 'int') {
        $value = ($info['size'] == 'tiny') ? (bool) $value : (int) $value;
      }

      $output .= $indent . '$' . $identifier . '->' . $field . ' = ' . views_var_export($value, $indent) . ";\n";
    }
    return $output;
  }

view::get_base_tables

(

)

Create a list of base tables eligible for this view.

Used primarily for the UI. Display must be already initialized.

Definition at line 335 of file view.inc.

                             {
    $base_tables = array(
      $this->base_table => TRUE,
      '#global' => TRUE,
    );

    foreach ($this->display_handler->get_handlers('relationship') as $handler) {
      $base_tables[$handler->definition['base']] = TRUE;
    }
    return $base_tables;
  }

view::get_breadcrumb

(

$

set = FALSE

)

Get the breadcrumb used for this view.

Parameters:

$set

If true, use drupal_set_breadcrumb() to install the breadcrumb.

Definition at line 1180 of file view.inc.

References $title.

                                        {
    // Now that we've built the view, extract the breadcrumb.
    $base = TRUE;
    $breadcrumb = array();

    if (!empty($this->build_info['breadcrumb'])) {
      foreach ($this->build_info['breadcrumb'] as $path => $title) {
        // Check to see if the frontpage is in the breadcrumb trail; if it
        // is, we'll remove that from the actual breadcrumb later.
        if ($path == variable_get('site_frontpage', 'node')) {
          $base = FALSE;
          $title = t('Home');
        }
        if ($title) {
          $breadcrumb[] = l($title, $path, array('html' => true));
        }
      }

      if ($set) {
        if ($base) {
          $breadcrumb = array_merge(drupal_get_breadcrumb(), $breadcrumb);
        }
        drupal_set_breadcrumb($breadcrumb);
      }
    }
    return $breadcrumb;
  }

view::get_exposed_input

(

)

Figure out what the exposed input for this view is.

Definition at line 153 of file view.inc.

References $display_id.

                               {
    // Fill our input either from $_GET or from something previously set on the
    // view.
    if (empty($this->exposed_input)) {
      $this->exposed_input = $_GET;
      // unset items that are definitely not our input:
      foreach (array('page', 'q') as $key) {
        if (isset($this->exposed_input[$key])) {
          unset($this->exposed_input[$key]);
        }
      }

      // If we have no input at all, check for remembered input via session.

      // If filters are not overridden, store the 'remember' settings on the
      // default display. If they are, store them on this display. This way,
      // multiple displays in the same view can share the same filters and
      // remember settings.
      $display_id = ($this->display_handler->is_defaulted('filters')) ? 'default' : $this->current_display;

      if (empty($this->exposed_input) && !empty($_SESSION['views'][$this->name][$display_id])) {
        $this->exposed_input = $_SESSION['views'][$this->name][$display_id];
      }
    }

    return $this->exposed_input;
  }

views_db_object::get_item	(	$	display_id,
		$	type,
		$	id
	)			[inherited]

Get the configuration of an item (field/sort/filter/etc) on a given display.

Definition at line 1918 of file view.inc.

References $display_id, and views_object_types().

Referenced by views_db_object::set_item_option().

                                             {
    // Get info about the types so we can get the right data.
    $types = views_object_types();
    // Initialize the display
    $this->set_display($display_id);

    // Get the existing configuration
    $fields = $this->display[$display_id]->handler->get_option($types[$type]['plural']);

    return isset($fields[$id]) ? $fields[$id] : NULL;
  }

views_db_object::get_items	(	$	type,
		$	display_id = NULL
	)			[inherited]

Get an array of items for the current display.

Definition at line 1902 of file view.inc.

References $display_id, and views_object_types().

                                                {
    $this->set_display($display_id);

    if (!isset($display_id)) {
      $display_id = $this->current_display;
    }

    // Get info about the types so we can get the right data.
    $types = views_object_types();
    return $this->display[$display_id]->handler->get_option($types[$type]['plural']);
  }

view::get_path

(

)

Get the base path used for this view.

Definition at line 1161 of file view.inc.

References set_display().

Referenced by get_url().

                      {
    if (!empty($this->override_path)) {
      return $this->override_path;
    }

    if (empty($this->display_handler)) {
      if (!$this->set_display('default')) {
        return FALSE;
      }
    }
    return $this->display_handler->get_path();
  }

view::get_title

(

)

Get the view's current title.

This can change depending upon how it was built.

Definition at line 1075 of file view.inc.

References $title, and set_display().

                       {
    if (empty($this->display_handler)) {
      if (!$this->set_display('default')) {
        return FALSE;
      }
    }

    // During building, we might find a title override. If so, use it.
    if (!empty($this->build_info['title'])) {
      $title = $this->build_info['title'];
    }
    else {
      $title = $this->display_handler->get_option('title');
    }

    return $title;
  }

view::get_url	(	$	args = NULL,
		$	path = NULL
	)

Get the URL for the current view.

This URL will be adjusted for arguments.

Definition at line 1111 of file view.inc.

References $args, and get_path().

Referenced by _build_arguments().

                                               {
    if (!isset($path)) {
      $path = $this->get_path();
    }
    if (!isset($args)) {
      $args = $this->args;
    }
    // Don't bother working if there's nothing to do:
    if (empty($path) || (empty($args) && strpos($path, '%') === FALSE)) {
      return $path;
    }

    $pieces = array();
    $arguments = isset($arguments) ? $arguments : $this->display_handler->get_option('arguments');
    $argument_keys = isset($arguments) ? array_keys($arguments) : array();
    $id = current($argument_keys);
    foreach (explode('/', $path) as $piece) {
      if ($piece != '%') {
        $pieces[] = $piece;
      }
      else {
        if (empty($args)) {
          // Try to never put % in a url; use the wildcard instead.
          if ($id && !empty($arguments[$id]['wildcard'])) {
            $pieces[] = $arguments[$id]['wildcard'];
          }
          else {
            $pieces[] = '*'; // gotta put something if there just isn't one.
          }

        }
        else {
          $pieces[] = array_shift($args);
        }

        if ($id) {
          $id = next($argument_keys);
        }
      }
    }

    if (!empty($args)) {
      $pieces = array_merge($pieces, $args);
    }
    return implode('/', $pieces);
  }

views_db_object::init

(

$

init = TRUE

)

[inherited]

Initialize this object, setting values from schema defaults.

Parameters:

$init

If an array, this is a set of values from db_fetch_object to load. Otherwse, if TRUE values will be filled in from schema defaults.

Definition at line 1622 of file view.inc.

References $field, and views_db_object::load_row().

                              {
    if (is_array($init)) {
      return $this->load_row($init);
    }

    if (!$init) {
      return;
    }

    $schema = drupal_get_schema($this->db_table);

    if (!$schema) {
      return;
    }

    // Go through our schema and build correlations.
    foreach ($schema['fields'] as $field => $info) {
      if ($info['type'] == 'serial') {
        $this->$field = NULL;
      }
      if (!isset($this->$field)) {
        if (!empty($info['serialize']) && isset($info['serialized default'])) {
          $this->$field = unserialize($info['serialized default']);
        }
        else if (isset($info['default'])) {
          $this->$field = $info['default'];
        }
        else {
          $this->$field = '';
        }
      }
    }
  }

view::init_display

(

$

reset = FALSE

)

Set the display for this view and initialize the display handler.

Definition at line 184 of file view.inc.

Referenced by access(), build_title(), choose_display(), export(), set_display(), and validate().

                                        {
    // The default display is always the first one in the list.
    if (isset($this->current_display)) {
      return TRUE;
    }

    // Instantiate all displays
    foreach (array_keys($this->display) as $id) {
      // Correct for shallow cloning
      // Often we'll have a cloned view so we don't mess up each other's
      // displays, but the clone is pretty shallow and doesn't necessarily
      // clone the displays. We can tell this by looking to see if a handler
      // has already been set; if it has, but $this->current_display is not
      // set, then something is dreadfully wrong.
      if (!empty($this->display[$id]->handler)) {
        $this->display[$id] = drupal_clone($this->display[$id]);
        unset($this->display[$id]->handler);
      }
      $this->display[$id]->handler = views_get_plugin('display', $this->display[$id]->display_plugin);
      if (!empty($this->display[$id]->handler)) {
        // Initialize the new display handler with data.
        $this->display[$id]->handler->init($this, $this->display[$id]);
        // If this is NOT the default display handler, let it know which is
        // since it may well utilize some data from the default.
        // This assumes that the 'default' handler is always first. It always
        // is. Make sure of it.
        if ($id != 'default') {
          $this->display[$id]->handler->default_display = &$this->display['default']->handler;
        }
      }
    }

    $this->current_display = 'default';
    $this->display_handler = &$this->display['default']->handler;

    return TRUE;
  }

view::init_handlers

(

)

Acquire and attach all of the handlers.

Definition at line 322 of file view.inc.

References _init_handler(), and views_object_types().

Referenced by build(), and build_title().

                           {
    if (empty($this->inited)) {
      foreach (views_object_types() as $key => $info) {
        $this->_init_handler($key, $info);
      }
      $this->inited = TRUE;
    }
  }

view::init_query

(

)

Do some common building initialization.

Definition at line 527 of file view.inc.

Referenced by build(), and build_title().

                        {
    // Create and initialize the query object.
    $views_data = views_fetch_data($this->base_table);
    $this->base_field = $views_data['table']['base']['field'];
    if (!empty($views_data['table']['base']['database'])) {
      $this->base_database = $views_data['table']['base']['database'];
    }
    views_include('query');
    $this->query = new views_query($this->base_table, $this->base_field);
  }

view::init_style

(

)

Find and initialize the style plugin.

Note that arguments may have changed which style plugin we use, so check the view object first, then ask the display handler.

Definition at line 298 of file view.inc.

Referenced by build(), and render().

                        {
    if (isset($this->style_plugin)) {
      return is_object($this->style_plugin);
    }

    if (!isset($this->plugin_name)) {
      $this->plugin_name = $this->display_handler->get_option('style_plugin');
      $this->style_options = $this->display_handler->get_option('style_options');
    }

    $this->style_plugin = views_get_plugin('style', $this->plugin_name);

    if (empty($this->style_plugin)) {
      return FALSE;
    }

    // init the new display handler with data.
    $this->style_plugin->init($this, $this->display[$this->current_display], $this->style_options);
    return TRUE;
  }

view::is_cacheable

(

)

Is this view cacheable?

Definition at line 1211 of file view.inc.

                          {
    return $this->is_cacheable;
  }

& view::load	(	$	arg,
		$	reset = FALSE
	)

Load a view from the database based upon either vid or name.

This is a static factory method that implements internal caching for view objects.

Parameters:

	$arg	The name of the view or its internal view id (vid)
	$reset	If TRUE, reset this entry in the load cache.

Returns:

A view object or NULL if it was not available.

Definition at line 1282 of file view.inc.

References $result, db_objects(), and view().

                                       {
    static $cache = array();

    // We want a NULL value to return TRUE here, so we can't use isset() or empty().
    if (!array_key_exists($arg, $cache) || $reset) {
      $where = (is_numeric($arg) ? "vid =  %d" : "name = '%s'");
      $data = db_fetch_object(db_query("SELECT * FROM {views_view} WHERE $where", $arg));
      if (empty($data)) {
        $cache[$arg] = NULL;
      }
      else {
        $view = new view();
        $view->load_row($data);
        $view->type = t('Normal');
        // Load all of our subtables.
        foreach ($view->db_objects() as $key) {
          $object_name = "views_$key";
          $result = db_query("SELECT * FROM {{$object_name}} WHERE vid = %d ORDER BY position", $view->vid);

          while ($data = db_fetch_object($result)) {
            $object = new $object_name(FALSE);
            $object->load_row($data);

            // Because it can get complicated with this much indirection,
            // make a shortcut reference.
            $location = &$view->$key;

            // If we have a basic id field, load the item onto the view based on
            // this ID, otherwise push it on.
            if (!empty($object->id)) {
              $location[$object->id] = $object;
            }
            else {
              $location[] = $object;
            }
          }
        }

        $view->loaded = TRUE;
        $cache[$arg] = $view;
      }
    }

    return $cache[$arg];
  }

views_db_object::load_row

(

$

data

)

[inherited]

Load the object with a row from the database.

This method is separate from the constructor in order to give us more flexibility in terms of how the view object is built in different contexts.

Parameters:

$data

An object from db_fetch_object. It should contain all of the fields that are in the schema.

Definition at line 1730 of file view.inc.

References $field.

Referenced by views_db_object::init().

                           {
    $schema = drupal_get_schema($this->db_table);

    // Go through our schema and build correlations.
    foreach ($schema['fields'] as $field => $info) {
      $this->$field = empty($info['serialize']) ? $data->$field : unserialize(db_decode_blob($data->$field));
    }
  }

view::load_views

(

)

Static factory method to load a list of views based upon a $where clause.

Although this method could be implemented to simply iterate over views::load(), that would be very slow. Buiding the views externally from unified queries is much faster.

Definition at line 1335 of file view.inc.

References $result, and db_objects().

                        {
    $result = db_query("SELECT DISTINCT v.* FROM {views_view} v");
    $views = array();
    $vids = array();

    // Load all the views.
    while ($data = db_fetch_object($result)) {
      $view = new view;
      $view->load_row($data);
      $view->loaded = TRUE;
      $view->type = t('Normal');
      $views[$view->name] = $view;
      $names[$view->vid] = $view->name;
    }

    // Stop if we didn't get any views.
    if (!$views) {
      return array();
    }

    $vids = implode(', ', array_keys($names));
    // Now load all the subtables:
    foreach (view::db_objects() as $key) {
      $object_name = "views_$key";
      $result = db_query("SELECT * FROM {{$object_name}} WHERE vid IN ($vids) ORDER BY vid, position");

      while ($data = db_fetch_object($result)) {
        $object = new $object_name(FALSE);
        $object->load_row($data);

        // Because it can get complicated with this much indirection,
        // make a shortcut reference.
        $location = &$views[$names[$object->vid]]->$key;

        // If we have a basic id field, load the item onto the view based on
        // this ID, otherwise push it on.
        if (!empty($object->id)) {
          $location[$object->id] = $object;
        }
        else {
          $location[] = $object;
        }
      }
    }
    return $views;
  }

& views_db_object::new_display	(	$	type = 'page',
		$	title = NULL,
		$	id = NULL
	)			[inherited]

Create a new display and a display handler for it.

Parameters:

	$type	The plugin type from the views plugin data. Defaults to 'page'.
	$title	The title of the display; optional, may be filled in from default.
	$id	The id to use.

Returns:

A reference to the new handler object.

Definition at line 1843 of file view.inc.

References $title, and views_db_object::add_display().

                                                                   {
    $id = $this->add_display($type, $title, $id);

    // Create a handler
    $this->display[$id]->handler = views_get_plugin('display', $this->display[$id]->display_plugin);
    if (empty($this->display[$id]->handler)) {
      // provide a 'default' handler as an emergency. This won't work well but
      // it will keep things from crashing.
      $this->display[$id]->handler = views_get_plugin('display', 'default');
    }

    if (!empty($this->display[$id]->handler)) {
      // Initialize the new display handler with data.
      $this->display[$id]->handler->init($this, $this->display[$id]);
      // If this is NOT the default display handler, let it know which is
      if ($id != 'default') {
        $this->display[$id]->handler->default_display = &$this->display['default']->handler;
      }
    }

    return $this->display[$id]->handler;
  }

view::post_execute

(

)

Unset the current view, mostly.

Definition at line 975 of file view.inc.

References $old_view.

Referenced by execute_display(), and preview().

                          {
    // unset current view so we can be properly destructed later on.
    // Return the previous value in case we're an attachment.

    if ($this->old_view) {
      $old_view = array_pop($this->old_view);
    }

    views_set_current_view(isset($old_view) ? $old_view : FALSE);
  }

view::pre_execute

(

$

args = array()

)

Run attachments and let the display do what it needs to do prior to running.

Definition at line 949 of file view.inc.

References $args, $display_id, and set_arguments().

Referenced by execute_display(), and preview().

                                        {
    $this->old_view[] = views_get_current_view();
    views_set_current_view($this);
    $display_id = $this->current_display;

    // Let modules modify the view just prior to executing it.
    foreach (module_implements('views_pre_view') as $module) {
      $function = $module . '_views_pre_view';
      $function($this, $display_id, $args);
    }

    // Prepare the view with the information we have, but only if we were
    // passed arguments, as they may have been set previously.
    if ($args) {
      $this->set_arguments($args);
    }

//    $this->attach_displays();

    // Allow the display handler to set up for execution
    $this->display_handler->pre_execute();
  }

view::preview	(	$	display_id = NULL,
		$	args = array()
	)

Preview the given display, with the given arguments.

To be called externally, probably by an AJAX handler of some flavor. Can also be called when views are embedded, as this guarantees normalized output.

Definition at line 929 of file view.inc.

References $args, $display_id, post_execute(), pre_execute(), and set_display().

                                                        {
    if (empty($this->current_display) || $this->current_display != $display_id) {
      if (!$this->set_display($display_id)) {
        return FALSE;
      }
    }

    $this->preview = TRUE;
    $this->pre_execute($args);
    // Preview the view.
    $output = $this->display_handler->preview();

    $this->post_execute();
    return $output;
  }

view::render

(

$

display_id = NULL

)

Render this view for display.

Definition at line 799 of file view.inc.

References $display_id, end_query_capture(), execute(), init_style(), and start_query_capture().

                                      {
    $this->execute($display_id);

    // Check to see if the build failed.
    if (!empty($this->build_info['fail'])) {
      return;
    }

    init_theme();

    $start = views_microtime();
    if (!empty($this->live_preview) && variable_get('views_show_additional_queries', FALSE)) {
      $this->start_query_capture();
    }

    // Check for already-cached output.
    if (!empty($this->live_preview)) {
      $cache = FALSE;
    }
    else {
      $cache = $this->display_handler->get_cache_plugin();
    }
    if ($cache && $cache->cache_get('output')) {
      vpr('Used cached output');
    }
    else {
      if ($cache) {
        $cache->cache_start();
      }

      // Initialize the style plugin.
      $this->init_style();

      $this->style_plugin->pre_render($this->result);

      // Let modules modify the view just prior to executing it.
      foreach (module_implements('views_pre_render') as $module) {
        $function = $module . '_views_pre_render';
        $function($this);
      }

      // Let the theme play too, because pre render is a very themey thing.
      $function = $GLOBALS['theme'] . '_views_pre_render';
      if (function_exists($function)) {
        $function($this, $this->display_handler->output, $cache);
      }

      // Give field handlers the opportunity to perform additional queries
      // using the entire resultset prior to rendering.
      if ($this->style_plugin->uses_fields()) {
        foreach ($this->field as $id => $handler) {
          if (!empty($this->field[$id])) {
            $this->field[$id]->pre_render($this->result);
          }
        }
      }
      $this->display_handler->output = $this->display_handler->render();
      if ($cache) {
        $cache->cache_set('output');
      }
    }

    if ($cache) {
      $cache->post_render($this->display_handler->output);
    }

    // Let modules modify the view output after it is rendered.
    foreach (module_implements('views_post_render') as $module) {
      $function = $module . '_views_post_render';
      $function($this, $this->display_handler->output, $cache);
    }

    // Let the theme play too, because post render is a very themey thing.
    $function = $GLOBALS['theme'] . '_views_post_render';
    if (function_exists($function)) {
      $function($this, $this->display_handler->output, $cache);
    }

    if (!empty($this->live_preview) && variable_get('views_show_additional_queries', FALSE)) {
      $this->end_query_capture();
    }
    $this->render_time = views_microtime() - $start;

    return $this->display_handler->output;
  }

view::render_exposed_form

(

$

block = FALSE

)

Render the exposed filter form.

This actually does more than that; because it's using FAPI, the form will also assign data to the appropriate handlers for use in building the query.

Definition at line 392 of file view.inc.

Referenced by build().

                                               {
    // Deal with any exposed filters we may have, before building.
    $form_state = array(
      'view' => &$this,
      'display' => &$this->display_handler->display,
      'method' => 'get',
      'rerender' => TRUE,
      'no_redirect' => TRUE,
    );

    // Some types of displays (eg. attachments) may wish to use the exposed
    // filters of their parent displays instead of showing an additional
    // exposed filter form for the attachment as well as that for the parent.
    if (!$this->display_handler->displays_exposed() || (!$block && $this->display_handler->get_option('exposed_block'))) {
      unset($form_state['rerender']);
    }

    if (!empty($this->ajax)) {
      $form_state['ajax'] = TRUE;
    }

    $output = drupal_build_form('views_exposed_form', $form_state);
    if (!empty($form_state['js settings'])) {
      $this->js_settings = $form_state['js settings'];
    }

    return $output;
  }

view::render_field	(	$	field,
		$	row
	)

Render a specific field via the field ID and the row #.

Definition at line 888 of file view.inc.

References $field.

                                      {
    if (isset($this->field[$field]) && isset($this->result[$row])) {
      return $this->field[$field]->advanced_render($this->result[$row]);
    }
  }

view::save

(

)

Save the view to the database.

If the view does not already exist, A vid will be assigned to the view and also returned from this function.

Definition at line 1386 of file view.inc.

References _save_rows(), db_objects(), and views_db_object::save_row().

                  {
    if ($this->vid == 'new') {
      $this->vid = NULL;
    }

    // If we have no vid or our vid is a string, this is a new view.
    if (!empty($this->vid)) {
      // remove existing table entries
      foreach ($this->db_objects() as $key) {
        db_query("DELETE from {views_" . $key . "} WHERE vid = %d", $this->vid);
      }
    }

    $this->save_row(!empty($this->vid) ? 'vid' : FALSE);

    // Save all of our subtables.
    foreach ($this->db_objects() as $key) {
      $this->_save_rows($key);
    }

    cache_clear_all('views_urls', 'cache_views');
    cache_clear_all(); // clear the page cache as well.
  }

views_db_object::save_row

(

$

update = NULL

)

[inherited]

Write the row to the database.

Parameters:

$update

If true this will be an UPDATE query. Otherwise it will be an INSERT.

Definition at line 1662 of file view.inc.

References $field.

Referenced by save().

                                    {
    $schema = drupal_get_schema($this->db_table);
    $fields = $defs = $values = $serials = array();

    // Go through our schema and build correlations.
    foreach ($schema['fields'] as $field => $info) {
      // special case -- skip serial types if we are updating.
      if ($info['type'] == 'serial') {
        $serials[] = $field;
        continue;
      }
      $fields[] = $field;
      switch ($info['type']) {
        case 'blob':
          $defs[] = '%b';
          break;
        case 'int':
          $defs[] = '%d';
          break;
        case 'float':
        case 'numeric':
          $defs[] = '%f';
          break;
        default:
          $defs[] = "'%s'";
      }
      if (empty($info['serialize'])) {
        $values[] = $this->$field;
      }
      else {
        $values[] = serialize($this->$field);
      }
    }
    $query = '';
    if (!$update) {
      $query = "INSERT INTO {" . $this->db_table . "} (" . implode(', ', $fields) . ') VALUES (' . implode(', ', $defs) . ')';
    }
    else {
      $query = '';
      foreach ($fields as $id => $field) {
        if ($query) {
          $query .= ', ';
        }
        $query .= $field . ' = ' . $defs[$id];
      }
      $query = "UPDATE {" . $this->db_table . "} SET " . $query . " WHERE $update = " . $this->$update;
    }
    db_query($query, $values);

    if ($serials && !$update) {
      // get last insert ids and fill them in.
      foreach ($serials as $field) {
        $this->$field = db_last_insert_id($this->db_table, $field);
      }
    }
  }

view::set_arguments

(

$

args

)

Set the arguments that come to this view.

Usually from the URL but possibly from elsewhere.

Definition at line 90 of file view.inc.

References $args.

Referenced by pre_execute().

                                {
    $this->args = $args;
  }

view::set_current_page

(

$

page

)

Change/Set the current page for the pager.

Definition at line 107 of file view.inc.

                                   {
    $this->pager['current_page'] = $page;
  }

view::set_display

(

$

display_id = NULL

)

Set the display as current.

Parameters:

$display_id

The id of the display to mark as current.

Definition at line 250 of file view.inc.

References $display_id, choose_display(), and init_display().

Referenced by build(), execute_display(), execute_hook_block(), execute_hook_menu(), get_path(), get_title(), and preview().

                                           {
    // If we have not already initialized the display, do so. But be careful.
    if (empty($this->current_display)) {
      $this->init_display();

      // If handlers were not initialized, and no argument was sent, set up
      // to the default display.
      if (empty($display_id)) {
        $display_id = 'default';
      }
    }

    $display_id = $this->choose_display($display_id);

    // If no display id sent in and one wasn't chosen above, we're finished.
    if (empty($display_id)) {
      return TRUE;
    }

    // Ensure the requested display exists.
    if (empty($this->display[$display_id])) {
      $display_id = 'default';
      if (empty($this->display[$display_id])) {
        vpr(t('set_display() called with invalid display id @display.', array('@display' => $display_id)));
        return FALSE;
      }
    }

    // Set the current display.
    $this->current_display = $display_id;

    // Ensure requested display has a working handler.
    if (empty($this->display[$display_id]->handler)) {
      return FALSE;
    }

    // Set a shortcut
    $this->display_handler = &$this->display[$display_id]->handler;

    return TRUE;
  }

view::set_exposed_input

(

$

filters

)

Set the exposed filters input to an array.

If unset they will be taken from $_GET when the time comes.

Definition at line 146 of file view.inc.

                                       {
    $this->exposed_input = $filters;
  }

views_db_object::set_item	(	$	display_id,
		$	type,
		$	id,
		$	item
	)			[inherited]

Get the configuration of an item (field/sort/filter/etc) on a given display.

Pass in NULL for the $item to remove an item.

Definition at line 1936 of file view.inc.

References $display_id, $item, and views_object_types().

Referenced by views_db_object::set_item_option().

                                                    {
    // Get info about the types so we can get the right data.
    $types = views_object_types();
    // Initialize the display
    $this->set_display($display_id);

    // Get the existing configuration
    $fields = $this->display[$display_id]->handler->get_option($types[$type]['plural']);
    if (isset($item)) {
      $fields[$id] = $item;
    }
    else {
      unset($fields[$id]);
    }

    // Store.
    $this->display[$display_id]->handler->set_option($types[$type]['plural'], $fields);
  }

views_db_object::set_item_option	(	$	display_id,
		$	type,
		$	id,
		$	option,
		$	value
	)			[inherited]

Set an option on an item.

Use this only if you have just 1 or 2 options to set; if you have many, consider getting the item, adding the options and doing set_item yourself.

Definition at line 1962 of file view.inc.

References $display_id, $item, views_db_object::get_item(), and views_db_object::set_item().

                                                                     {
    $item = $this->get_item($display_id, $type, $id);
    $item[$option] = $value;
    $this->set_item($display_id, $type, $id, $item);
  }

view::set_items_per_page

(

$

items_per_page

)

Set the page size for ranged or pager queries.

Definition at line 97 of file view.inc.

                                               {
    $this->pager['items_per_page'] = $items_per_page;
    if (empty($items_per_page)) {
      $this->pager['use_pager'] = FALSE;
    }
  }

view::set_offset

(

$

offset

)

How many records to skip.

This does not function if use_pager is set.

Definition at line 129 of file view.inc.

                               {
    $this->pager['offset'] = $offset;
  }

view::set_pager_element

(

$

pager_element

)

The pager element id to use if use_apger is on.

Definition at line 121 of file view.inc.

                                             {
    $this->pager['element'] = $pager_element;
  }

view::set_use_ajax

(

$

use_ajax

)

Whether or not AJAX should be used.

If AJAX is used, paging, tablesorting and exposed filters will be fetched via an AJAX call rather than a page refresh.

Definition at line 138 of file view.inc.

References $use_ajax.

                                   {
    $this->use_ajax = $use_ajax;
  }

view::set_use_pager

(

$

use_pager

)

Whether or not the pager should be used.

Definition at line 114 of file view.inc.

                                     {
    $this->pager['use_pager'] = $use_pager;
  }

view::start_query_capture

(

)

Set up query capturing.

db_query() stores the queries that it runs in global $queries, bit only if dev_query is set to true. In this case, we want to temporarily override that setting if it's not and we can do that without forcing a db rewrite by just manipulating $conf. This is kind of evil but it works.

Definition at line 1224 of file view.inc.

Referenced by render().

                                 {
    global $conf, $queries;
    if (empty($conf['dev_query'])) {
      $this->fix_dev_query = TRUE;
      $conf['dev_query'] = TRUE;
    }

    // Record the last query key used; anything already run isn't
    // a query that we are interested in.
    $this->last_query_key = NULL;

    if (!empty($queries)) {
      $keys = array_keys($queries);
      $this->last_query_key = array_pop($keys);
    }
  }

view::validate

(

)

Make sure the view is completely valid.

Returns:

TRUE if the view is valid; an array of error strings if it is not.

Definition at line 1588 of file view.inc.

References $result, and init_display().

                      {
    $this->init_display();

    $errors = array();

    foreach ($this->display as $id => $display) {
      if ($display->handler) {
        if (!empty($display->deleted)) {
          continue;
        }

        $result = $this->display[$id]->handler->validate();
        if (!empty($result) && is_array($result)) {
          $errors = array_merge($errors, $result);
        }
      }
    }

    return $errors ? $errors : TRUE;
  }

view::view

(

)

Constructor.

Definition at line 57 of file view.inc.

References db_objects().

Referenced by load().

                  {
    parent::init();
    // Make sure all of our sub objects are arrays.
    foreach ($this->db_objects() as $object) {
      $this->$object = array();
    }

    $this->query = new stdClass();
  }

---

Member Data Documentation

view::$pager

Initial value:

 array(
    'use_pager' => FALSE,
    'items_per_page' => 10,
    'element' => 0,
    'offset' => 0,
    'current_page' => 0,
  )

Definition at line 36 of file view.inc.

---

The documentation for this class was generated from the following file:

• includes/view.inc

---