panels.module File Reference

(1.10.4.127 2008/11/05 02:24:15 sdboyer)

---

Detailed Description

Core API for Panels. Provides display editing and rendering capabilities.

Definition in file panels.module.

Go to the source code of this file.

Classes
class	panels_display
Functions
	panels_add_button ($image, $name, $text, $class, $id=NULL)
	panels_ajax_form ($form_id, $title, $url)
	panels_ajax_passthru ()
	panels_ajax_render ($output=NULL, $title=NULL, $url=NULL)
	panels_api_version ()
	panels_cache_clear ($did)
	panels_cache_get ($did)
	panels_cache_set ($did, $cache)
	panels_common_cache_clear ($obj, $did)
	panels_common_cache_get ($obj, $did, $skip_cache=FALSE)
	panels_common_cache_set ($obj, $did, $cache)
	panels_cron ()
	panels_delete_display ($display)
	panels_edit ($display, $destination=NULL, $content_types=NULL)
	panels_edit_layout ($display, $finish, $destination=NULL, $allowed_layouts=NULL)
	panels_edit_layout_settings ($display, $finish, $destination=NULL, $title=FALSE)
	panels_elements ()
	panels_export_display ($display, $prefix= '')
	panels_export_pane ($pane, $prefix= '')
	panels_get ($var)
	panels_get_panel_style_and_settings ($panel_settings, $panel)
	panels_get_path ($file, $base_path=false, $module= 'panels')
	panels_help ($section=NULL)
	panels_imagebutton_value ()
	panels_load_display ($did)
	panels_load_displays ($dids)
	panels_load_include ($include, $path= 'includes/')
	panels_menu ($may_cache)
	panels_new_display ()
	panels_nid_autocomplete ($int)
	panels_node_autocomplete ($string)
	panels_node_type ($op, $info)
	panels_perm ()
	panels_print_layout ($id, $content)
	panels_print_layout_icon ($id, $layout, $title=NULL)
	panels_print_layout_link ($id, $layout, $link)
	panels_render_display (&$display)
	panels_render_layout ($layout, $content, $css_id=NULL, $settings=array())
	panels_render_pane ($content, $pane, $display)
	panels_render_pane_content (&$display, &$pane)
	panels_render_panel ($display, $panel, $panes)
	panels_render_panes ($display)
	panels_sanitize_display (&$display)
	panels_save_display (&$display)
	panels_set ($var, $value=NULL)
	panels_var_export ($object, $prefix= '')
	theme_panels_imagebutton ($element)
	theme_panels_layout_icon ($id, $image, $title=NULL)
	theme_panels_layout_link ($title, $id, $image, $link)
	theme_panels_pane ($content, $pane, $display)

---

Function Documentation

panels_add_button	(	$	image,
		$	name,
		$	text,
		$	class,
		$	id = NULL
	)

Add a single button to a form.

Definition at line 279 of file panels.module.

References panels_get_path().

Referenced by panels_common_add_item_to_form(), panels_content_config_add_form_submit(), and panels_edit_display().

                                                                     {
  return array(
    '#type' => 'panels_imagebutton',
    '#image' => panels_get_path('images/' . $image),
    '#title' => $text,
    '#default_value' => $name,
    '#class' => $class,
    '#id' => $id,
  );
}

Here is the call graph for this function:

Here is the caller graph for this function:

panels_ajax_form	(	$	form_id,
		$	title,
		$	url
	)

Handle a form for AJAX in a manner that happens to be basically the opposite of the normal flow; if the form hasn't been processed, just render it and exit; if it has been submitted successfuly, however, then we return whatever the submit function returned and do our next step accordingly.

Parameters:

	$form_id	The id of the form
	$title	The title for the modal dialog, if rendered.
	$url	The next URL to go to; may be NULL.
	...	Any arguments that go to the form.

Definition at line 208 of file panels.module.

References panels_ajax_render().

Referenced by panels_ajax_add_config(), panels_ajax_cache(), panels_ajax_cache_settings(), panels_ajax_configure(), and panels_panel_settings_ajax().

                                                  {
  $args = func_get_args();

  // Remove the $title and $url
  array_splice($args, 1, 2);

  $form = call_user_func_array('drupal_retrieve_form', $args);
  $form['#redirect'] = FALSE;

  $result = drupal_process_form($form_id, $form);
  if (isset($result)) {
    return $result;
  }

  // If the form wasn't submitted successfully, render the form.
  $output = theme('status_messages');
  $output .= drupal_render_form($form_id, $form);
  panels_ajax_render($output, $title, $url);
}

Here is the call graph for this function:

Here is the caller graph for this function:

panels_ajax_passthru

(

)

Helper function for our AJAX stuff to call through to the right location

Definition at line 147 of file panels.module.

References panels_load_include().

                                {
  $args = func_get_args();
  $callback = array_shift($args);

  panels_load_include('plugins');
  if (arg(1) == 'common') {
    panels_load_include('common');
  }
  else {
    panels_load_include('display_edit');
  }
  return call_user_func_array($callback, $args);
}

Here is the call graph for this function:

panels_ajax_render	(	$	output = NULL,
		$	title = NULL,
		$	url = NULL
	)

Simple render function to make sure output is what we want.

Definition at line 166 of file panels.module.

Referenced by panels_ajax(), panels_ajax_add_config(), panels_ajax_add_content(), panels_ajax_cache(), panels_ajax_cache_settings(), panels_ajax_configure(), panels_ajax_form(), panels_ajax_toggle_shown(), panels_common_ajax(), panels_common_ajax_context_item_add(), panels_common_ajax_context_item_edit(), panels_edit_submit_subform(), and panels_panel_settings_ajax().

                                                                        {
  if (!is_object($output)) {
    $temp = new stdClass();
    $temp->output = $output;
    switch ($output) {
      case 'dismiss':
        $temp->type = $output;
        break;

      default:
        $temp->type = 'display';
    }
    $temp->title = $title;
    $temp->url   = $url;
    $output      = $temp;
  }
  if (!$output->output || !$output->type) {
    $output->output = t('The input was invalid');
    $output->type   = 'display';
    $output->title  = t('Error');
  }
  drupal_set_header('Content-Type: text/javascript; charset=utf-8');
  print drupal_to_js($output);
  exit;
}

Here is the caller graph for this function:

panels_api_version

(

)

Returns the API version of Panels. This didn't exist in 1.

Returns:

An array with the major and minor versions

Definition at line 32 of file panels.module.

                              {
  return array(2, 0);
}

panels_cache_clear

(

$

did

)

Clear a display from the cache; used if the editing is aborted.

Definition at line 311 of file panels.module.

References panels_common_cache_clear().

Referenced by _panels_edit(), and panels_edit_display_submit().

                                  {
  return panels_common_cache_clear('panels', $did);
}

Here is the call graph for this function:

Here is the caller graph for this function:

panels_cache_get

(

$

did

)

Get a display from the cache; this is used if the display is currently being edited, which can be a seriously multi-step process.

Definition at line 297 of file panels.module.

References panels_common_cache_get().

Referenced by _panels_edit(), panels_ajax(), panels_ajax_add_config(), panels_ajax_add_content(), panels_ajax_cache(), panels_ajax_configure(), and panels_ajax_toggle_shown().

                                {
  return panels_common_cache_get('panels', $did);
}

Here is the call graph for this function:

Here is the caller graph for this function:

panels_cache_set	(	$	did,
		$	cache
	)

Save the edited display into the cache.

Definition at line 304 of file panels.module.

References panels_common_cache_set().

Referenced by _panels_edit(), panels_ajax_add_config(), panels_ajax_cache_settings(), panels_ajax_configure(), panels_ajax_toggle_shown(), panels_content_config_form(), and panels_content_config_form_submit().

                                        {
  return panels_common_cache_set('panels', $did, $cache);
}

Here is the call graph for this function:

Here is the caller graph for this function:

panels_common_cache_clear	(	$	obj,
		$	did
	)

Clear a display from the cache; used if the editing is aborted.

Definition at line 348 of file panels.module.

Referenced by panels_cache_clear(), panels_common_cache_set(), panels_mini_context_form_submit(), panels_node_context_form_submit(), panels_page_context_form_submit(), and panels_panel_settings_submit().

                                               {
  db_query("DELETE FROM {panels_object_cache} WHERE sid = '%s' AND obj = '%s' AND did = %d", session_id(), $obj, $did);
}

Here is the caller graph for this function:

panels_common_cache_get	(	$	obj,
		$	did,
		$	skip_cache = FALSE
	)

Get an object from cache.

Definition at line 321 of file panels.module.

Referenced by panels_cache_get(), panels_common_ajax_context_item_add(), panels_common_ajax_context_item_edit(), panels_mini_edit_context(), panels_node_context_edit(), panels_page_edit_context(), panels_panel_settings(), panels_panel_settings_ajax(), and panels_panel_settings_validate().

                                                                  {
  static $cache = array();
  $key = "$obj:$did";
  if ($skip_cache) {
    unset($cache[$key]);
  }

  if (!array_key_exists($key, $cache)) {
    $data = db_fetch_object(db_query("SELECT * FROM {panels_object_cache} WHERE sid = '%s' AND obj = '%s' AND did = %d", session_id(), $obj, $did));
    if ($data) {
      $cache[$key] = unserialize($data->data);
    }
  }
  return isset($cache[$key]) ? $cache[$key] : NULL;
}

Here is the caller graph for this function:

panels_common_cache_set	(	$	obj,
		$	did,
		$	cache
	)

Save the edited display into the cache.

Definition at line 340 of file panels.module.

References panels_common_cache_clear().

Referenced by panels_cache_set(), panels_common_ajax_context_item_add(), panels_common_ajax_context_item_edit(), panels_mini_edit_context(), panels_node_context_edit(), panels_page_edit_context(), panels_panel_settings(), and panels_panel_settings_ajax().

                                                     {
  panels_common_cache_clear($obj, $did);
  db_query("INSERT INTO {panels_object_cache} (sid, obj, did, data, timestamp) VALUES ('%s', '%s', %d, '%s', %d)", session_id(), $obj, $did, serialize($cache), time());
}

Here is the call graph for this function:

Here is the caller graph for this function:

panels_cron

(

)

Clean up old caches

Definition at line 355 of file panels.module.

                       {
  // delete anything 7 days old or more.
  db_query("DELETE FROM {panels_object_cache} WHERE timestamp < %d", time() - (86400 * 7));
}

panels_elements

(

)

Custom form element to do our nice images.

Definition at line 251 of file panels.module.

                           {
  $type['panels_imagebutton'] = array('#input' => TRUE, '#button_type' => 'submit');
  return $type;
}

panels_export_pane	(	$	pane,
		$	prefix = ''
	)

Definition at line 877 of file panels.module.

References panels_var_export().

Referenced by panels_export_display().

                                                 {
  $output = '';
  $output = $prefix . '$pane = new stdClass()'  . ";\n";
  $fields = array('pid', 'panel', 'type', 'subtype', 'shown', 'access', 'visibility', 'configuration', 'cache');
  foreach ($fields as $field) {
    $output .= "$prefix  " . '$pane->' . $field . ' = ' . panels_var_export($pane->$field, "$prefix  ") . ";\n";
  }
  return $output;
}

Here is the call graph for this function:

Here is the caller graph for this function:

panels_get

(

$

var

)

Retrieve from global storage

Definition at line 375 of file panels.module.

References panels_set().

Referenced by panels_edit_submit_subform().

                          {
  return panels_set($var);
}

Here is the call graph for this function:

Here is the caller graph for this function:

panels_get_panel_style_and_settings	(	$	panel_settings,
		$	panel
	)

Given a display and the id of a panel, get the style in which to render that panel.

Definition at line 1151 of file panels.module.

References panels_get_style().

Referenced by panels_render_panel().

                                                                      {
  if (empty($panel_settings)) {
    return array(panels_get_style('default'), array());
  }

  if (empty($panel_settings['individual']) || empty($panel_settings['panel'][$panel]['style'])) {
    $style = panels_get_style($panel_settings['style']);
    $style_settings = $panel_settings['style_settings']['default'];
  }
  else {
    $style = panels_get_style($panel_settings['panel'][$panel]['style']);
    $style_settings = $panel_settings['style_settings'][$panel];
  }

  return array($style, $style_settings);
}

Here is the call graph for this function:

Here is the caller graph for this function:

panels_get_path	(	$	file,
		$	base_path = false,
		$	module = 'panels'
	)

panels path helper function

Definition at line 231 of file panels.module.

Referenced by _panels_js_files(), panels_add_button(), panels_add_content(), panels_admin_content_types_custom(), panels_admin_content_types_custom_php(), panels_admin_content_types_form(), panels_admin_content_types_node_attachments(), panels_admin_content_types_node_book_nav(), panels_admin_content_types_node_comment_form(), panels_admin_content_types_node_comments(), panels_admin_content_types_node_content(), panels_admin_content_types_node_form(), panels_admin_content_types_node_meta(), panels_admin_content_types_node_type_desc(), panels_admin_content_types_term_description(), panels_admin_content_types_term_list(), panels_admin_content_types_user_picture(), panels_admin_content_types_user_profile(), panels_admin_content_types_vocabulary_terms(), panels_choose_layout(), panels_common_add_context_js(), panels_common_set_allowed_layouts(), panels_common_settings(), panels_edit_display(), panels_flexible_settings_form(), panels_load_include(), panels_menu(), panels_mini_content_types(), panels_mini_context_form(), panels_mini_edit_form(), panels_node_context_form(), panels_page_advanced_form(), panels_page_context_form(), panels_page_edit_form(), panels_panel_settings(), panels_print_layout_icon(), panels_print_layout_link(), panels_profile_fields_content_type(), panels_render_layout(), panels_views_content_types(), theme_panels_export_export_form(), theme_panels_hidden(), and theme_rounded_corners_css().

                                                                        {
  if ($base_path) {
    $output = base_path();
  }
  return $output . drupal_get_path('module', $module) . '/' . $file;
}

Here is the caller graph for this function:

panels_help

(

$

section = NULL

)

Definition at line 9 of file panels.module.

                                      {
  $output = '';
  switch ($section) {
    case 'admin/help#panels':
    case 'admin/panels':
      $output = '<p>'. t(' Panels module is the core engine for a number of sub-modules, including Panels pages, Panels nodes, Mini panels, and Views panes. Panels module allows the website adminstrator (or sometimes the end-user) to manipulate the layout of individual pages, sidebars, and content pieces, as well as easily dictate what content is displayed in the layout.') .'</p>';
      $output .= '<p>'. t('Most Drupal users are familiar with the block to region layout mechanism in which you can assign a block to any region defined in your theme.  Panels takes this concept a massive step forward.  Through the panels interface you can start by creating a layout with any number of columns, headers, and footer, and control the width of those areas.') .'</p>';
      $output .= '<p>'. t('After creating your layout, you can assign pieces of content to those areas in an easy drag and drop interface.  Content is not limited to blocks, but can be nodes, views, or other types of content that expose themselves to panels.') .'</p>';
      $output .= '<p><b>'. t('Panel pages') .'</b>'. t(' are the the primary panels module, you can use this for creating single full page layouts.  This replaces the standard panel that existed in the earlier versions of panels. If you are upgrading your site from Panels 1, and you cannot find where your panels went, be sure to enable the panel pages module!') .'</p>';
      $output .= '<p><b>'. t('Panel nodes') .'</b>'. t(' are useful for creating layouts that only occupy the content area of your pages.  Frequently, it is desirable to add an area to a node layout, such as a pull quote for a newspaper or a photo block, that you don\'t necessarily want on every node.  Panels Nodes lets you control the layout of a single node at a time and place content such as blog posts, images, blogs in and around the post.') .'</p>';
      $output .= '<p><b>'. t('Mini panels') .'</b>'. t(' are a layout mechanism for blocks.  It won\'t take long using panels before you get to a point when you want a panel inside of a panel.  Or a panel that can be used as a block.  That is exactly what mini-panels does. You can create a small panel here with various pieces of content and then put it inside of a panels-page or panels-node.') .'</p>';
      $output .= '<p><b>'. t('Views panes') .'</b>'. t(" expose views so they may be added to panels. Panels will automatically detect block views without this module; however, page and embedded views will <strong>not be</strong> selectable from Panels by default. If you enable the <strong>Views panes</strong> module, you may expose individual views to Panels. The <strong>Legacy views panes</strong> module will simply expose all views, so that you may add them in any panel. Both modules provide options for customization of the views' settings on a per-Panel basis. This is useful if you have multiple administrators or want to use panels for something other than just panel pages.") .'</p>';
      $output .= '<p>' . t('If you do not see the above items in the list below, you may need to activate them on the <a href="!url">module administration</a> page.', array('!url' => url('admin/build/modules'))) . '</p>';

      return $output;
  }
}

panels_imagebutton_value

(

)

Definition at line 272 of file panels.module.

                                    {
  // null function guarantees default_value doesn't get moved to #value.
}

panels_load_include	(	$	include,
		$	path = 'includes/'
	)

Load a panels include file.

Definition at line 140 of file panels.module.

References panels_get_path().

Referenced by _panels_edit_layout(), panels_allowed_layouts::list_layouts(), panels_ajax_passthru(), panels_common_get_allowed_types(), panels_common_get_layout_information(), panels_common_settings(), panels_edit(), panels_edit_layout(), panels_edit_layout_settings(), panels_mini_add_page(), panels_mini_block(), panels_mini_content(), panels_mini_context_form(), panels_mini_edit_content(), panels_mini_edit_form(), panels_mini_list_page(), panels_mini_preview_panel(), panels_mini_settings(), panels_node_add(), panels_node_context_edit(), panels_node_context_form(), panels_node_edit_content(), panels_node_edit_layout(), panels_node_edit_layout_settings(), panels_node_form(), panels_node_settings(), panels_node_view(), panels_page_context_form(), panels_page_edit_content(), panels_page_edit_form(), panels_page_menu(), panels_page_passthru(), panels_page_settings(), panels_page_view_page(), panels_print_layout(), panels_render_display(), panels_save_display(), panels_update_5209(), and panels_views_edit_view_form().

                                                            {
  require_once './' . panels_get_path("$path$include.inc");
}

Here is the call graph for this function:

Here is the caller graph for this function:

panels_menu

(

$

may_cache

)

Implementation of hook_menu

Definition at line 39 of file panels.module.

References panels_get_path().

                                 {
  if ($may_cache) {
    $items[] = array(
      'path' => 'admin/panels',
      'title' => t('Panels'),
      'access' => user_access('access administration pages'),
      'callback' => 'system_admin_menu_block_page',
      'description' => t('Administer items related to the Panels module.'),
    );
    $items[] = array(
      'path' => 'panels/node/autocomplete',
      'title' => t('Autocomplete node'),
      'callback' => 'panels_node_autocomplete',
      'access' => user_access('access content'),
      'type' => MENU_CALLBACK,
    );
    // TODO Deprecated generalized ajax handler. Remove if at all possible.
    $items[] = array(
      'path' => 'panels/ajax',
      'title' => t('ajax'),
      'callback' => 'panels_ajax_passthru',
      'callback arguments' => array('panels_ajax'),
      'access' => user_access('access content'),
      'type' => MENU_CALLBACK,
    );
    $items[] = array(
      'path' => 'panels/common/ajax',
      'title' => t('ajax'),
      'callback' => 'panels_ajax_passthru',
      'callback arguments' => array('panels_common_ajax'),
      'access' => user_access('access content'),
      'type' => MENU_CALLBACK,
    );
    $items[] = array(
      'path' => 'panels/ajax/add-content',
      'title' => t('ajax'),
      'callback' => 'panels_ajax_passthru',
      'callback arguments' => array('panels_ajax_add_content'),
      'access' => user_access('access content'),
      'type' => MENU_CALLBACK,
    );
    $items[] = array(
      'path' => 'panels/ajax/add-config',
      'title' => t('ajax'),
      'callback' => 'panels_ajax_passthru',
      'callback arguments' => array('panels_ajax_add_config'),
      'access' => user_access('access content'),
      'type' => MENU_CALLBACK,
    );
    $items[] = array(
      'path' => 'panels/ajax/configure',
      'title' => t('ajax'),
      'callback' => 'panels_ajax_passthru',
      'callback arguments' => array('panels_ajax_configure'),
      'access' => user_access('access content'),
      'type' => MENU_CALLBACK,
    );
    $items[] = array(
      'path' => 'panels/ajax/toggle-shown',
      'title' => t('ajax'),
      'callback' => 'panels_ajax_passthru',
      'callback arguments' => array('panels_ajax_toggle_shown'),
      'access' => user_access('access content'),
      'type' => MENU_CALLBACK,
    );
    $items[] = array(
      'path' => 'panels/ajax/cache',
      'title' => t('ajax'),
      'callback' => 'panels_ajax_passthru',
      'callback arguments' => array('panels_ajax_cache'),
      'access' => user_access('access content'),
      'type' => MENU_CALLBACK,
    );
    $items[] = array(
      'path' => 'panels/ajax/cache-settings',
      'title' => t('ajax'),
      'callback' => 'panels_ajax_passthru',
      'callback arguments' => array('panels_ajax_cache_settings'),
      'access' => user_access('access content'),
      'type' => MENU_CALLBACK,
    );
    $items[] = array(
      'path' => 'panels/ajax/panel_settings',
      'title' => t('ajax'),
      'callback' => 'panels_ajax_passthru',
      'callback arguments' => array('panels_panel_settings_ajax'),
      'access' => user_access('access content'),
      'type' => MENU_CALLBACK,
    );
  }
  else {
    drupal_add_css(panels_get_path('css/panels.css'));
    drupal_add_js(panels_get_path('js/panels.js'));
  }

  return $items;
}

Here is the call graph for this function:

panels_nid_autocomplete

(

$

int

)

Helper function for parsing an autocomplete node field.

Parameters:

$string

A string in autocomplete syntax (e.g. ".... [nid: 123]"), or a typed-in nid, or a node title.

Returns:

Either a valid nid or NULL.

Definition at line 1313 of file panels.module.

Referenced by panels_context_node_edit_form_settings_form_validate(), panels_context_node_settings_form_validate(), and panels_node_legacy_edit_validate().

                                       {
  $nid = NULL;
  if (is_numeric($int)) {
    // The user typed a NID outright.
    $nid = $int;
  }
  else {
    // Else, it might be an autocomplete syntax.
    $preg_matches = array();
    $match = preg_match('/\[nid: (\d+)\]/', $int, $preg_matches)
             || preg_match('/^nid: (\d+)/', $int, $preg_matches);
    if ($match) {
      $nid = $preg_matches[1];
    }
  }
  if (isset($nid)) {
    // Verify that node exists and we have access to it.
    $node = db_fetch_object(db_query(db_rewrite_sql("SELECT n.nid FROM {node} n WHERE n.nid = %d"), $nid));
  }
  else {
    // Try to find a node having that title.
    $node = db_fetch_object(db_query(db_rewrite_sql("SELECT n.nid FROM {node} n WHERE LOWER(n.title) = LOWER('%s')"), $int));
  }
  if ($node) {
    return $node->nid;
  }
}

Here is the caller graph for this function:

panels_node_autocomplete

(

$

string

)

Helper function for autocompletion of node titles. This is mostly stolen from clipper.

Definition at line 1344 of file panels.module.

                                           {
  // TODO: Compare this to the nodequeue version, see which is better.
  // TODO: The nodequeue version is totally better. Steal it.
  // if there are node_types passed, we'll use those in a MySQL IN query.
  if ($string != '') {
    $preg_matches = array();
    $match = preg_match('/\[nid: (\d+)\]/', $string, $preg_matches);
    if (!$match) {
      $match = preg_match('/^nid: (\d+)/', $string, $preg_matches);
    }
    if ($match) {
      $arg = $preg_matches[1];
      $where = "n.nid = %d";
    }
    else {
      $arg = $string;
      $where = "LOWER(title) LIKE LOWER('%%%s%%')";
    }
    $result = db_query_range(db_rewrite_sql("SELECT n.nid, n.title, u.name FROM {node} n INNER JOIN {users} u ON u.uid = n.uid WHERE $where"), $arg, 0, 10);

    $matches = array();
    while ($node = db_fetch_object($result)) {
      $name = empty($node->name) ? variable_get('anonymous', t('Anonymous')) : check_plain($node->name);
      $matches[$node->title . " [nid: $node->nid]"] = '<span class="autocomplete_title">'. check_plain($node->title) .'</span> <span class="autocomplete_user">('. t('by @user', array('@user' => $name)) .')</span>';
    }
    drupal_set_header('Content-Type: text/javascript; charset=utf-8');
    print drupal_to_js($matches);
  }
}

panels_node_type	(	$	op,
		$	info
	)

Implementation of hook_node_type().

We implement this hook to update any pane contexts that are reliant on a specific node type with the new type name.

Definition at line 1380 of file panels.module.

                                      {
  if ($op == 'update') {
    if (!empty($info->old_type) && $info->old_type != $info->type) {
      // Exclude a few common pane types that we know don't use context.
      $result = db_query("SELECT * FROM {panels_pane} WHERE type NOT IN ('block', 'custom')");
      while ($pane = db_fetch_object($result)) {
        // Check the serialized data for the presence of context data.
        if (!preg_match('/s:7:\"context/', $pane->configuration) || stripos($pane->configuration, 'node-' . $info->old_type) === FALSE) {
          // There's no context/no mention of our node type - next!
          continue;
        }
        $conf = unserialize($pane->configuration);
        // Manage panes with multiple contexts stored in an array.
        if (is_array($conf['context'] && ($keys = array_keys($conf['context'], 'node-' . $info->old_type)))) {
          foreach ($keys as $key) {
            $conf['context'][$key] = 'node-' . $info->type;
          }
          db_query("UPDATE {panels_pane} SET configuration = '%s' WHERE pid = %d", serialize($conf), $pane->pid);
        }
        // Manage single-context panes.
        else if ($conf['context'] == 'node-' . $info->old_type) {
          $conf['context'] = 'node-' . $info->type;
          db_query("UPDATE {panels_pane} SET configuration = '%s' WHERE pid = %d", serialize($conf), $pane->pid);
        }
      }
    }
  }
}

panels_perm

(

)

Implementation of hook_perm

Definition at line 241 of file panels.module.

                       {
  return array('view all panes', 'view pane admin links', 'administer pane visibility', 'administer pane access', 'administer advanced pane settings', 'use panels caching features');
}

panels_print_layout	(	$	id,
		$	content
	)

For external use: Given a layout ID and a $content array, return the panel display. The content array is filled in based upon the content available in the layout. If it's a two column with a content array defined like array('left' => t('Left side'), 'right' => t('Right side')), then the $content array should be array('left' => $output_left, 'right' => $output_right)

Definition at line 949 of file panels.module.

References panels_get_layout(), panels_load_include(), and panels_render_layout().

                                            {
  panels_load_include('plugins');
  $layout = panels_get_layout($id);
  if (!$layout) {
    return;
  }

  return panels_render_layout($layout, $content);
}

Here is the call graph for this function:

panels_print_layout_icon	(	$	id,
		$	layout,
		$	title = NULL
	)

Definition at line 1212 of file panels.module.

References panels_get_path().

Referenced by panels_change_layout(), panels_choose_layout(), panels_common_get_layout_information(), panels_common_set_allowed_layouts(), panels_mini_edit_form(), and panels_page_edit_form().

                                                               {
  drupal_add_css(panels_get_path('css/panels_admin.css'));
  $file = panels_get_path($layout['icon'], false, $layout['module']);
  return theme('panels_layout_icon', $id, theme('image', $file), $title);
}

Here is the call graph for this function:

Here is the caller graph for this function:

panels_print_layout_link	(	$	id,
		$	layout,
		$	link
	)

Print the layout link. Sends out to a theme function.

Definition at line 1203 of file panels.module.

References panels_get_path().

Referenced by panels_mini_add_page(), panels_node_add(), and panels_page_add_page().

                                                       {
  drupal_add_css(panels_get_path('css/panels_admin.css'));
  $file  = panels_get_path($layout['icon'], false, $layout['module']);
  $image = l(theme('image', $file), $link, NULL, NULL, NULL, NULL, TRUE);
  $title = l($layout['title'], $link);
  return theme('panels_layout_link', $title, $id, $image, $link);
}

Here is the call graph for this function:

Here is the caller graph for this function:

panels_render_layout	(	$	layout,
		$	content,
		$	css_id = NULL,
		$	settings = array()
	)

Given a full layout structure and a content array, render a panel display.

Definition at line 963 of file panels.module.

References panels_get_cached_content(), panels_get_path(), panels_render_panes(), and panels_set_cached_content().

Referenced by panels_print_layout(), panels_render_display(), and theme_panels_edit_display().

                                                                                      {
  if (!empty($layout['css'])) {
    if (file_exists(path_to_theme() . '/' . $layout['css'])) {
      drupal_add_css(path_to_theme() . '/' . $layout['css']);
    }
    else {
      drupal_add_css(panels_get_path($layout['css'], false, $layout['module']));
    }
  }
  $display = NULL;

  // This now comes after the CSS is added, because panels-within-panels must
  // have their CSS added in the right order; inner content before outer content.

  // If $content is an object, it's a $display and we have to render its panes.
  if (is_object($content)) {
    $display = $content;
    if (empty($display->cache['method'])) {
      $content = panels_render_panes($display);
    }
    else {
      $cache = panels_get_cached_content($display, $display->args, $display->context);
      if ($cache === FALSE) {
        $cache = new panels_cache_object();
        $cache->set_content(panels_render_panes($display));
        panels_set_cached_content($cache, $display, $display->args, $display->context);
      }
      $content = $cache->content;
    }
  }

  $output = theme($layout['theme'], check_plain($css_id), $content, $settings, $display);

  return $output;
}

Here is the call graph for this function:

Here is the caller graph for this function:

panels_render_pane	(	$	content,
		$	pane,
		$	display
	)

Render a pane using the appropriate style.

$content The already rendered content via panels_render_pane_content() $pane The $pane information from the display $display The display.

Definition at line 1127 of file panels.module.

References panels_get_style().

Referenced by theme_panels_default_style_render_panel(), theme_panels_list_style_render_panel(), and theme_panels_rounded_corners_style_render_panel().

                                                       {
  if (!empty($pane->configuration['style'])) {
    $style = panels_get_style($pane->configuration['style']);

    if (isset($style)) {
      $output = theme($style['render pane'], $content, $pane, $display);

      // This could be null if no theme function existed.
      if (isset($output)) {
        return $output;
      }
    }
  }

  if (!empty($content)) {
    // fallback
    return theme('panels_pane', $content, $pane, $display);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

panels_render_pane_content	(	&$	display,
		&$	pane
	)

Render a single pane, identifying its context, and put it into the $panes array.

Definition at line 1059 of file panels.module.

References panels_get_pane_content(), and panels_pane_select_context().

Referenced by panels_render_panes().

                                                       {
  if (empty($pane->context)) {
    $pane->context = panels_pane_select_context($pane, $display->context);
    if ($pane->context === FALSE) {
      return FALSE;
    }
  }

  $content = panels_get_pane_content($display, $pane, $display->args, $pane->context, $display->incoming_content);

  $keywords = !empty($display->keywords) ? $display->keywords : array();
  // Override the title if configured to
  if (!empty($pane->configuration['override_title'])) {
    // Give previous title as an available substitution here.
    $keywords['%title'] = $content->title;
    $content->title = $pane->configuration['override_title_text'];
  }

  // Pass long the css_id that is usually available.
  if (!empty($pane->configuration['css_id'])) {
    $content->css_id = $pane->configuration['css_id'];
  }

  // Pass long the css_class that is usually available.
  if (!empty($pane->configuration['css_class'])) {
    $content->css_class = $pane->configuration['css_class'];
  }

  if (!empty($content->title)) {
    // Perform substitutions
    if (!empty($keywords)) {
      $content->title = strtr($content->title, $keywords);
    }

    // Sterilize the title
    $content->title = filter_xss_admin($content->title);

    // If a link is specified, populate.
    if (!empty($content->title_link)) {
      if (!is_array($content->title_link)) {
        $url = array('href' => $content->title_link);
      }
      else {
        $url = $content->title_link;
      }
      // set defaults so we don't bring up notices
      $url += array('href' => '', 'attributes' => NULL, 'query' => NULL, 'fragment' => NULL, 'absolute' => NULL);
      $content->title = l($content->title,
        $url['href'],
        $url['attributes'],
        $url['query'],
        $url['fragment'],
        $url['absolute'], TRUE);
    }
  }
  return $content;
}

Here is the call graph for this function:

Here is the caller graph for this function:

panels_render_panel	(	$	display,
		$	panel,
		$	panes
	)

Render a panel, by storing the content of each pane in an appropriate array and then passing through to the theme function that will render the panel in the configured panel style.

Parameters:

	$display	A display object.
	$panel	The ID of the panel being rendered
	$panes	An array of panes that are assigned to the panel that's being rendered.

Returns:

The rendered HTML for a panel.

Definition at line 1184 of file panels.module.

References panels_get_panel_style_and_settings().

Referenced by panels_render_panes().

                                                       {
  list($style, $style_settings) = panels_get_panel_style_and_settings($display->panel_settings, $panel);

  // Retrieve the pid (can be a panel page id, a mini panel id, etc.), this
  // might be used (or even necessary) for some panel display styles.
  // TODO: Got to fix this to use panel page name instead of pid, since pid is
  // no longer guaranteed. This needs an API to be able to set the final id.
  $owner_id = 0;
  if (isset($display->owner) && is_object($display->owner) && isset($display->owner->id)) {
    $owner_id = $display->owner->id;
  }

  return theme($style['render panel'], $display, $owner_id, $panes, $style_settings, $panel);
}

Here is the call graph for this function:

Here is the caller graph for this function:

panels_render_panes

(

$

display

)

Render all the panes in a display into a $content array to be used by the display theme function.

Definition at line 1003 of file panels.module.

References panels_get_content_type(), panels_pane_access(), panels_render_pane_content(), and panels_render_panel().

Referenced by panels_render_layout().

                                       {
  // Safety check.
  if (empty($display->content)) {
    return array();
  }

  // First, render all the panes into little boxes. We do this here because
  // some panes request to be rendered after other panes (primarily so they
  // can do the leftovers of forms).
  $panes = array();
  $later = array();

  foreach ($display->content as $pid => $pane) {
    $pane->shown = isset($pane->shown) ? $pane->shown : TRUE;
    // TODO Really ought to design a method for creating a quick-access set of content_type (and other plugin) data to help optimize render performance
    // If the user can't see this pane, do not render it.
    if (!$pane->shown || !panels_pane_access($pane, $display)) {
      continue;
    }

    // If this pane wants to render last, add it to the $later array.
    $content_type = panels_get_content_type($pane->type);

    if (!empty($content_type['render last'])) {
      $later[$pid] = $pane;
      continue;
    }

    $panes[$pid] = panels_render_pane_content($display, $pane);
  }

  foreach ($later as $pid => $pane) {
    $panes[$pid] = panels_render_pane_content($display, $pane);
  }

  // Loop through all panels, put all panes that belong to the current panel
  // in an array, then render the panel. Primarily this ensures that the
  // panes are in the proper order.
  $content = array();
  foreach ($display->panels as $panel_name => $pids) {
    $panel = array();
    foreach ($pids as $pid) {
      if (!empty($panes[$pid])) {
        $panel[$pid] = $panes[$pid];
      }
    }
    $content[$panel_name] = panels_render_panel($display, $panel_name, $panel);
  }

  return $content;
}

Here is the call graph for this function:

Here is the caller graph for this function:

panels_sanitize_display

(

&$

display

)

Clean up a display and make sure it has some required information if it doesn't already exist. Currently we require a context, an incoming content and a css_id.

Definition at line 615 of file panels.module.

Referenced by panels_render_display().

                                            {
  if (!isset($display->args)) {
    $display->args = array();
  }

  if (!isset($display->incoming_content)) {
    $display->incoming_content = NULL;
  }

  if (!isset($display->context)) {
    $display->context = array();
  }

  if (!isset($display->css_id)) {
    $display->css_id = NULL;
  }
}

Here is the caller graph for this function:

panels_set	(	$	var,
		$	value = NULL
	)

Global storage function, used mostly so that _submit hooks can pass data back to their originator more easily. TODO: deprecated but still in use.

Definition at line 364 of file panels.module.

Referenced by panels_add_content(), and panels_get().

                                         {
  static $vars = array();
  if ($value !== NULL) {
    $vars[$var] = $value;
  }
  return $vars[$var];
}

Here is the caller graph for this function:

panels_var_export	(	$	object,
		$	prefix = ''
	)

Definition at line 887 of file panels.module.

Referenced by panels_export_display(), panels_export_pane(), panels_mini_export(), panels_page_export(), and panels_views_export().

                                                  {
  if (is_array($object) && empty($object)) {
    $output = 'array()';
  }
  else {
    $output = var_export($object, TRUE);
  }

  if ($prefix) {
    $output = str_replace("\n", "\n$prefix", $output);
  }
  return $output;
}

Here is the caller graph for this function:

theme_panels_imagebutton

(

$

element

)

Theme our image button.

Definition at line 259 of file panels.module.

                                            {
  return '<input type="image" ' .
    'class="form-' . $element['#button_type'] . ' ' . $element['#class'] . '" ' .
    'name="'. $element['#name'] .'" ' .
    'value="'. check_plain($element['#default_value']) .'" ' .
    'id="' . $element['#id'] . '" ' .
    drupal_attributes($element['#attributes']) .
    ' src="' . base_path() . $element['#image'] . '" ' .
    'alt="' . $element['#title'] . '" ' .
    'title="' . $element['#title'] . '" ' .
    "/>\n";
}

theme_panels_layout_icon	(	$	id,
		$	image,
		$	title = NULL
	)

Theme the layout icon image

Definition at line 1234 of file panels.module.

                                                              {
  $output .= '<span class="layout-icon">';
  $output .= $image;
  if ($title) {
    $output .= '<span class="caption">' . $title . '</span>';
  }
  $output .= '</span>';
  return $output;
}

theme_panels_layout_link	(	$	title,
		$	id,
		$	image,
		$	link
	)

Theme the layout link image

Definition at line 1222 of file panels.module.

                                                              {
  $output .= '<div class="layout-link">';
  $output .= $image;
  $output .= '<div>' . $title . '</div>';
  $output .= '</div>';
  return $output;
}

theme_panels_pane	(	$	content,
		$	pane,
		$	display
	)

Render a panel pane like a block.

A panel pane can have the following fields:

• $pane->type -- the content type inside this pane
• $pane->subtype -- The subtype, if applicable. If a view it will be the view name; if a node it will be the nid, etc.
• $content->title -- The title of the content
• $content->content -- The actual content
• $content->links -- Any links associated with the content
• $content->more -- An optional 'more' link (destination only)
• $content->admin_links -- Administrative links associated with the content
• $content->feeds -- Any feed icons or associated with the content
• $content->subject -- A legacy setting for block compatibility
• $content->module -- A legacy setting for block compatibility
• $content->delta -- A legacy setting for block compatibility

Definition at line 1262 of file panels.module.

                                                      {
  if (!empty($content->content)) {
    $idstr = $classstr = '';
    if (!empty($content->css_id)) {
      $idstr = ' id="' . $content->css_id . '"';
    }
    if (!empty($content->css_class)) {
      $classstr = ' ' . $content->css_class;
    }

    $output = "<div class=\"panel-pane$classstr\"$idstr>\n";
    if (user_access('view pane admin links') && !empty($content->admin_links)) {
      $output .= "<div class=\"admin-links panel-hide\">" . theme('links', $content->admin_links) . "</div>\n";
    }
    if (!empty($content->title)) {
      $output .= "<h2 class=\"title\">$content->title</h2>\n";
    }

    if (!empty($content->feeds)) {
      $output .= "<div class=\"feed\">" . implode(' ', $content->feeds) . "</div>\n";
    }

    $output .= "<div class=\"content\">$content->content</div>\n";

    if (!empty($content->links)) {
      $output .= "<div class=\"links\">" . theme('links', $content->links) . "</div>\n";
    }


    if (!empty($content->more)) {
      if (empty($content->more['title'])) {
        $content->more['title'] = t('more');
      }
      $output .= "<div class=\"more-link\">" . l($content->more['title'], $content->more['href']) . "</div>\n";
    }

    $output .= "</div>\n";
    return $output;
  }
}