Panels Ajax Handlers

---

Detailed Description

These functions comprise Panels' ajax handling on the php end. They're pretty much only used for admin/editing at the moment.

Functions
	_panels_ajax_ct_preconfigure (&$cache, &$pane)
	panels_add_content ($cache, $panel_id)
	panels_ajax_add_config ($did=NULL, $pane_info=NULL)
	panels_ajax_add_content ($did=NULL, $panel_id=NULL)
	panels_ajax_cache ($did=NULL, $pid=NULL)
	panels_ajax_cache_settings ($cache, $pid, $method=NULL)
	panels_ajax_configure ($did=NULL, $pid=NULL)
	panels_ajax_set_cache_data (&$display, $pid, $method, $settings=array())
	panels_ajax_toggle_shown ($did=NULL, $pid=NULL, $op=NULL)
	panels_common_style_settings_form ($did, $style, $style_settings)
	panels_content_config_edit_form_submit ($form_values, $cache, $pane)
	panels_content_config_form ($cache, $pane, $add=FALSE)
	panels_content_config_form_submit ($form_id, $form_values)
	panels_edit_cache_method_form ($display, $pid)
	panels_edit_cache_method_form_submit ($form_id, $form_values)
	panels_edit_cache_settings_form ($display, $pid, $method, $settings_function)
	panels_edit_cache_settings_form_submit ($form_id, $form_values)
	panels_edit_submit_subform ($display)
	panels_panel_settings ($display)
	panels_panel_settings_ajax ($did, $panel, $name)

---

Function Documentation

_panels_ajax_ct_preconfigure	(	&$	cache,
		&$	pane
	)

Helper function for ajax pane type editing callbacks. When needed, preps the cached $display object with relevant data from the content type.

Parameters:

	array	$cache The loaded $cache object containing all the current $display editing data.
	object	$pane The $pane object this ajax callback intends to operate on.

See also:

panels_ajax_configure()

panels_ajax_add_config()

Definition at line 975 of file display_edit.inc.

References panels_get_content_type(), and panels_plugin_get_function().

Referenced by panels_ajax_add_config(), and panels_ajax_configure().

                                                       {
  $cc = &$cache->content_config[$pane->pid];
  // indicates that the data for this pane has been built for this round of edits and need not be rebuilt
  $cc['built'] = TRUE;
  $subtype = $cc['ct_data']['subtype'] = $cache->content_types[$pane->type][$pane->subtype];
  $type = $cc['ct_data']['type'] = panels_get_content_type($pane->type);

  $cc['ignore_roles'] = !$type['role-based access'];

  if (panels_plugin_get_function('content_types', $type, 'visibility control')) {
    $cc['visibility_controller'] = $type['visibility control'];
    // defaults to NOT using the built-in pane access system if the ct defines a visibility callback
    $cc['ignore_roles'] = TRUE;
    if (isset($type['roles and visibility']) && $type['roles and visibility'] === TRUE) {
      $cc['ignore_roles'] = FALSE;
    }
  }

  if (panels_plugin_get_function('content_types', $type, 'form control')) {
    $cc['form_controller'] = $type['form control'];
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

panels_add_content	(	$	cache,
		$	panel_id
	)

Definition at line 723 of file display_edit.inc.

References panels_get_available_content_types(), panels_get_path(), and panels_set().

Referenced by panels_ajax_add_content().

                                               {
  $return = new stdClass();
  $return->type  = 'display';
  $return->title = t('Choose type');
  // TODO get rid of this deprecated method
  panels_set('return', $return);

  if (!isset($cache->content_types)) {
    $cache->content_types = panels_get_available_content_types();
  }

  $weights    = array(t('Contributed modules') => 0);
  $categories = array();
  $titles     = array();

  foreach ($cache->content_types as $type_name => $subtypes) {
    if (is_array($subtypes)) {
      foreach ($subtypes as $subtype_name => $subtype_info) {
        $title = filter_xss_admin($subtype_info['title']);
        $description = isset($subtype_info['description']) ? $subtype_info['description'] : $title;

        if (isset($subtype_info['icon'])) {
          $icon = $subtype_info['icon'];
          $path = isset($subtype_info['path']) ? $subtype_info['path'] : panels_get_path("content_types/$type_name");
        }
        else {
          $icon = 'no-icon.png';
          $path = panels_get_path('images');
        }

        if (isset($subtype_info['category'])) {
          if (is_array($subtype_info['category'])) {
            list($category, $weight) = $subtype_info['category'];
            $weights[$category] = $weight;
          }
          else {
            $category = $subtype_info['category'];
            if (!isset($weights['category'])) {
              $weights[$category] = 0;
            }
          }
        }
        else {
          $category = t('Contrib modules');
        }

        $output = '<div class="content-type-button clear-block">';
        $link_text = theme('image', $path . '/' . $icon, $description, $description);
        $output .= l($link_text, 'javascript: void()', array('class' => 'panels-modal-add-config', 'id' => $type_name . '-' . $panel_id . '-' . $subtype_name), NULL, NULL, NULL, TRUE);
        $output .= "<div>" . l($title, 'javascript: void()', array('class' => 'panels-modal-add-config', 'id' => $type_name . '-' . $panel_id . '-' . $subtype_name), NULL, NULL, NULL, TRUE) . "</div>";
        $output .= '</div>';
        if (!isset($categories[$category])) {
          $categories[$category] = array();
          $titles[$category] = array();
        }

        $categories[$category][] = $output;
        $titles[$category][] = $title;
      }
    }
  }
  if (!$categories) {
    $output = t('There are no content types you may add to this display.');
  }
  else {
    asort($weights);
    $output = '';

    $columns = 3;
    foreach (range(1, $columns) as $column) {
      $col[$column] = '';
      $size[$column] = 0;
    }

    foreach ($weights as $category => $weight) {
      $which = 1; // default;
      $count = count($titles[$category]) + 3;
      // Determine which column to use by seeing which column has the most
      // free space. This algorithm favors left.
      foreach (range($columns, 2) as $column) {
        if ($size[$column - 1] - $size[$column] > $count / 2) {
          $which = $column;
          break;
        }
      }

      $col[$which] .= '<div class="panels-section">';
      $col[$which] .= '<h3 class="panels-section-title">' . $category . '</h3>';
      $col[$which] .= '<div class="panels-section-decorator"></div>';
      $col[$which] .= '<div class="panels-section-content">';
      if (is_array($titles[$category])) {
        natcasesort($titles[$category]);
        foreach ($titles[$category] as $id => $title) {
          $col[$which] .= $categories[$category][$id];
        }
      }
      $col[$which] .= '</div>';
      $col[$which] .= '</div>';
      $size[$which] += $count; // add 3 to account for title.
    }

    foreach ($col as $column) {
      $output .= '<div class="panels-section-column">' . $column . '</div>';
    }
  }
  return $output;
}

Here is the call graph for this function:

Here is the caller graph for this function:

panels_ajax_add_config	(	$	did = NULL,
		$	pane_info = NULL
	)

Entry point for AJAX: Add pane configuration.

After updating the $cache data and equipping a new $pane object with basic values, the general-purpose ajax form handler, panels_ajax_form(), is called and pushes the configuration form to the screen.

Once form submission is completed, data is pushed back into js by panels_ajax_render().

Parameters:

	int	$did The display id for the display object currently being edited. Errors out silently if absent.
	string	$pane_info A string generated by the following code in panels_add_content(): $output .= l($link_text, 'javascript: void()', array('class' => 'panels-modal-add-config', 'id' => $type_name . '-' . $panel_id . '-' . $subtype_name), NULL, NULL, NULL, TRUE); $type_name contains the name of the content type, $panel_id the name of the panel region to which the pane will be added, and $subtype_name is the name of the content subtype.

See also:

panels_content_config_form()

Definition at line 890 of file display_edit.inc.

References _panels_ajax_ct_preconfigure(), panels_ajax_form(), panels_ajax_render(), panels_cache_get(), and panels_cache_set().

                                                                {
  if ((is_numeric($did) || $did == 'new') && $cache = panels_cache_get($did)) {
    if (!isset($_POST['form_id'])) {
      $pid = $cache->display->next_new_pid();
      $pane = new stdClass();
      $pane->pid = "new-$pid";
      // Ensure there's no data relics.
      unset($cache->content_config[$pane->pid], $cache->pane);
      $cc = &$cache->content_config[$pane->pid];

      list($cc['content_type'], $cc['panel_id'], $cc['content_subtype']) = explode('-', $pane_info, 3);
      list($pane->type, $pane->subtype, $pane->configuration, $pane->access) = array($cc['content_type'], $cc['content_subtype'], array(), array());
      _panels_ajax_ct_preconfigure($cache, $pane);
      $cache->pane = drupal_clone($pane);
      panels_cache_set($did, $cache);
    }
    else {
      // Not the render passthrough, so the above data has been cached; we retrieve $pane from $cache.
      $pane = $cache->pane;
      unset($cache->pane);
    }

    $ajax_vars = panels_ajax_form('panels_content_config_form',
      t('Configure !subtype_title', array('!subtype_title' => $cache->content_config[$pane->pid]['ct_data']['subtype']['title'])),
      url($_GET['q'], NULL, NULL, TRUE), $cache, $pane, TRUE
    );
    panels_ajax_render($ajax_vars);
  }
  panels_ajax_render();
}

Here is the call graph for this function:

panels_ajax_add_content	(	$	did = NULL,
		$	panel_id = NULL
	)

Entry point for AJAX: 'Add Content' modal form, from which the user selects the type of pane to add.

Parameters:

	int	$did The display id of the $display object currently being edited.
	string	$panel_id A string with the name of the panel region to which the selected pane type will be added.

Definition at line 704 of file display_edit.inc.

References panels_add_content(), panels_ajax_render(), panels_cache_get(), panels_get_layout(), and panels_get_panels().

                                                                {
  $output = new stdClass();
  if ((is_numeric($did) || $did == 'new') && $cache = panels_cache_get($did)) {
    $display = $cache->display;
    $layout = panels_get_layout($display->layout);
    $layout_panels = panels_get_panels($layout, $display);

    if ($layout && array_key_exists($panel_id, $layout_panels)) {
      $output->output = panels_add_content($cache, $panel_id);
      $output->type   = 'display';
      $output->title  = t('Add content to !s', array('!s' => $layout_panels[$panel_id]));
    }
  }
  panels_ajax_render($output);
}

Here is the call graph for this function:

panels_ajax_cache	(	$	did = NULL,
		$	pid = NULL
	)

Entry point for AJAX modal: configure pane

Definition at line 1195 of file display_edit.inc.

References panels_ajax_cache_settings(), panels_ajax_form(), panels_ajax_render(), and panels_cache_get().

                                                     {
  if (!((is_numeric($did) || $did == 'new') && $cache = panels_cache_get($did))) {
    panels_ajax_render();
  }

  // First, check to see if this is a form being submitted and, if it is, which
  // one, because we can have two forms here.
  if (!empty($_POST) && !empty($_POST['form_id']) && $_POST['form_id'] == 'panels_edit_cache_settings_form') {
    return panels_ajax_cache_settings($cache, $pid);
  }

  $method = panels_ajax_form('panels_edit_cache_method_form',
    t('Select cache method'), url($_GET['q'], NULL, NULL, TRUE),
    $cache->display, $pid
  );
  return panels_ajax_cache_settings($cache, $pid, $method);
}

Here is the call graph for this function:

panels_ajax_cache_settings	(	$	cache,
		$	pid,
		$	method = NULL
	)

Handle the cache settings form

Definition at line 1266 of file display_edit.inc.

References panels_ajax_form(), panels_ajax_render(), panels_ajax_set_cache_data(), panels_cache_set(), and panels_plugin_get_function().

Referenced by panels_ajax_cache().

                                                                  {
  if (empty($method) && isset($_POST['method'])) {
    // Retrieve the method from the form.
    $method = $_POST['method'];
  }

  if (empty($method) || !($function = panels_plugin_get_function('cache', $method, 'settings form'))) {
    panels_ajax_set_cache_data($cache->display, $pid, 0);
  }
  else {
    $cache->display = panels_ajax_form('panels_edit_cache_settings_form',
      t('Configure cache settings'), url($_GET['q'], NULL, NULL, TRUE),
      $cache->display, $pid, $method, $function
    );
  }

  panels_cache_set($cache->display->did, $cache);

  if ($pid) {
    $ajax_vars = new stdClass();
    list($ajax_vars->id, $ajax_vars->output, $ajax_vars->type) = array($pid, 'Changed', 'dismiss-changed');
    panels_ajax_render($ajax_vars);
  }
  else {
    panels_ajax_render('dismiss');
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

panels_ajax_configure	(	$	did = NULL,
		$	pid = NULL
	)

Entry point for AJAX: Edit pane configuration.

Prepares the display $cache and a pre-existing $pane so that the pane configuration form for the $pane can be rendered.

Once form submission is completed, data is pushed back into js by panels_ajax_render().

Parameters:

	int	$did The display id of the display object currently being edited. Errors out silently if absent.
	The	pane id of the pane object whose configuration form we're calling up to edit.

See also:

panels_content_config_form()

Definition at line 938 of file display_edit.inc.

References _panels_ajax_ct_preconfigure(), panels_ajax_form(), panels_ajax_render(), panels_cache_get(), and panels_cache_set().

                                                         {
  if ((is_numeric($did) || $did == 'new') && $cache = panels_cache_get($did)) {
    if (isset($cache->display->content[$pid]) && $pane = $cache->display->content[$pid]) {
      // Only perform on a form rendering passthrough and if the data hasn't already been built.
      if (!isset($_POST['form_id']) && empty($cc['built'])) {
        $cc = &$cache->content_config[$pane->pid];
        if (!isset($cc)) {
          list($cc['content_type'], $cc['content_subtype']) = array($pane->type, $pane->subtype);
          _panels_ajax_ct_preconfigure($cache, $pane);
          panels_cache_set($did, $cache);
        }
      }

      $ajax_vars = panels_ajax_form('panels_content_config_form',
        t('Configure !subtype_title', array('!subtype_title' => $cache->content_config[$pane->pid]['ct_data']['subtype']['title'])),
        url($_GET['q'], NULL, NULL, TRUE), $cache, $pane
      );
      panels_ajax_render($ajax_vars);
    }
  }
  panels_ajax_render();
}

Here is the call graph for this function:

panels_ajax_set_cache_data	(	&$	display,
		$	pid,
		$	method,
		$	settings = array()
	)

Set the cache method and associated settings on the display.

Definition at line 1298 of file display_edit.inc.

Referenced by panels_ajax_cache_settings(), and panels_edit_cache_settings_form_submit().

                                                                                   {
  if ($pid) {
    $conf = &$display->content[$pid]->cache;
  }
  else {
    $conf = &$display->cache;
  }

  $conf['method'] = $method;
  $conf['settings'] = $settings;
}

Here is the caller graph for this function:

panels_ajax_toggle_shown	(	$	did = NULL,
		$	pid = NULL,
		$	op = NULL
	)

Entry point for AJAX: toggle pane show/hide status.

Parameters:

	int	$did The display id for the display object currently being edited. Errors out silently if absent.
	int	$pid The pane id for the pane object whose show/hide state we're toggling.
	string	$op The operation - showing or hiding - that this should perform. This could be calculated from cached values, but given that this is a toggle button and people may click it too fast, it's better to leave the decision on which $op to use up to the js than to calculate it here.

Definition at line 845 of file display_edit.inc.

References panels_ajax_render(), panels_cache_get(), and panels_cache_set().

                                                                        {
  if ((is_numeric($did) || $did == 'new') && $cache = panels_cache_get($did)) {
    $ajax_vars = new stdClass();
    list($ajax_vars->type, $ajax_vars->id, $ajax_vars->old_op) = array('toggle-shown', $pid, drupal_strtolower($op));

    if ($op == 'Show') {
      list($cache->display->content[$pid]->shown, $ajax_vars->output, $ajax_vars->new_op) = array(1, 'Hide', 'hide');
    }
    elseif ($op == 'Hide') {
      list($cache->display->content[$pid]->shown, $ajax_vars->output, $ajax_vars->new_op) = array(0, 'Show', 'show');
    }
    else {
      // bad args, error out.
      panels_ajax_render();
    }

    panels_cache_set($cache->display->did, $cache);
    panels_ajax_render($ajax_vars);
  }
  panels_ajax_render();
}

Here is the call graph for this function:

panels_common_style_settings_form	(	$	did,
		$	style,
		$	style_settings
	)

Form for the style settings modal.

Definition at line 1599 of file display_edit.inc.

                                                                          {
  $form['start_form'] = array('#value' => '<div class="modal-form">');
  $form['description'] = array(
    '#prefix' => '<div class="description">',
    '#suffix' => '</div>',
    '#value' => check_plain($style['description']),
  );

  if (isset($style['settings form']) && function_exists($style['settings form'])) {
    $form['style_settings'] = $style['settings form']($style_settings);
    $form['style_settings']['#tree'] = TRUE;
  }
  else {
    $form['markup'] = array(
      '#value' => t('This style does not have any settings.'),
    );
  }
  $form['end_form'] = array('#value' => '</div>');

  if (!isset($form['markup'])) {
    $form['style'] = array(
      '#type' => 'value',
      '#value' => $style,
    );

    $form['did'] = array(
      '#type' => 'value',
      '#value' => $did,
    );

    $form['next'] = array(
      '#type' => 'submit',
      '#value' => t('Save'),
    );
  }

  return $form;
}

panels_content_config_edit_form_submit	(	$	form_values,
		$	cache,
		$	pane
	)

Definition at line 1175 of file display_edit.inc.

References _panels_render_preview_pane_disabled().

                                                                             {
  // If this content type defines its own 'editor render callback', we need to
  // invoke that again, since we're not doing a full panels_show_pane().
  $content_type = $cache->content_config[$pane->pid]['ct_data']['type'];
  if (function_exists($content_type['editor render callback'])) {
    $block = $content_type['editor render callback']($cache->display, $pane);
  }
  else {
    $block = _panels_render_preview_pane_disabled($pane, $cache->display->context);
  }
  $ajax_vars = new stdClass();
  $ajax_vars->type   = 'replace';
  $ajax_vars->output = theme('panels_pane_collapsible', $block, $cache->display);
  return $ajax_vars;
}

Here is the call graph for this function:

panels_content_config_form	(	$	cache,
		$	pane,
		$	add = FALSE
	)

Master FAPI definition for all pane add/edit configuration forms.

Parameters:

	object	$cache The $cache object for the panels $display currently being edited.
	object	$pane The $pane object currently being added/edited.
	bool	$add A boolean indicating whether we are adding a new pane ($add === TRUE) operation in this operation, or editing an existing pane ($add === FALSE).

Returns:

array $form A structured FAPI form definition, having been passed through all the appropriate content-type specific callbacks.

Definition at line 1015 of file display_edit.inc.

References panels_cache_set(), panels_ct_conf_form(), and panels_ct_pane_config_form().

                                                                 {
  $op = $add ? 'add' : 'edit';
  // for brevity and readability.
  $cc = $cache->content_config[$pane->pid];

  $form['start_form'] = array('#value' => '<div class="modal-form">');

  $form['configuration'] = panels_ct_conf_form($cc['ct_data'], $cache->display->context, $pane->configuration);
  if (is_array($form_additions = panels_ct_pane_config_form($pane, $cache->display->context, array('configuration'), $op))) {
    $form['configuration'] += $form_additions;
  }
  $form['configuration']['#tree'] = TRUE;

  if (!$cc['ignore_roles']) {
    if (user_access('administer pane access')) {
      $rids = array();
      $result = db_query("SELECT r.rid, r.name FROM {role} r ORDER BY r.name");
      while ($obj = db_fetch_object($result)) {
        $rids[$obj->rid] = $obj->name;
      }

      $form['access'] = array(
        '#type' => 'checkboxes',
        '#title' => t('Access'),
        '#default_value' => $add ? array() : $pane->access,
        '#options' => $rids,
        '#description' => t('Only the checked roles will be able to see this pane; if no roles are checked, access will not be restricted.'),
      );
    }
    else {
      $form['access'] = array(
        '#type' => 'value',
        '#value' => isset($pane->access) ? $pane->access : array(),
      );
    }
  }

  if (isset($cc['visibility_controller'])) {
    $form['visibility'] = $cc['visibility_controller']($cache->display->context, $pane->subtype, $pane->configuration, $add);
  }

  $form['end_form'] = array('#value' => '</div>');

  $form['next'] = array(
    '#type' => 'submit',
    '#value' => $add ? t('Add pane') : t('Save'),
  );

  $form['vars'] = array('#type' => 'value', '#value' => array($cache, $pane, $add, $op));

  // Allows content types that define this callback to have full control over the pane config form.
  if (isset($cc['form_controller'])) {
    call_user_func_array($cc['form_controller'], array(&$form, &$cache->content_config[$pane->pid], &$cache->display, $add));
    // Only set the cache with any new vars on the render passthrough; setting
    // it again could, depending on the changes in the plugin function, cause
    // serious data consistency problems.
    if (!isset($_POST['form_id'])) {
      panels_cache_set($cache->display->did, $cache);
    }
  }
  return $form;
}

Here is the call graph for this function:

panels_content_config_form_submit	(	$	form_id,
		$	form_values
	)

FAPI submit handler for panels_content_config_form().

Call any submit handlers defined by the content type, update the $cache object with the relevant data, save $cache to the object_cache table, and return data for ajax updates.

Returns:

object $ajax_vars Variables to be passed to the ajax handler so that the overall edit form can be updated as needed.

Definition at line 1102 of file display_edit.inc.

References panels_cache_set(), panels_ct_pane_submit_form(), and panels_plugin_get_function().

                                                                   {
  list($cache, $pane, $add, $op) = $form_values['vars'];
  // Start by saving all initial $pane values into the array of pane data in $display->content.
  $cache->display->content[$pane->pid] = $pane;
  // Call the submit handler provided by the pane type, if any.
  panels_ct_pane_submit_form($pane->type, $form_values['configuration'], $op);

  if (isset($form_values['visibility'])) {
    if ($visibility_submit = panels_plugin_get_function('content_types', $cache->content_config[$pane->pid]['ct_data']['type'], 'visibility submit')) {
      // Use call_user_func_array() in order to ensure that all these values can only be passed by value.
      $cache->display->content[$pane->pid]->visibility = call_user_func_array($visibility_submit,
        array($form_values['visibility'], $add, $cache->display->content[$pane->pid], $cache->display));
    }
    else {
      // If no visibility submit callback is defined, fall back to the default storage behavior. Should be
      // adequate for the vast majority of use cases, so most client modules won't need to define callbacks.
      $cache->display->content[$pane->pid]->visibility = is_array($form_values['visibility']) ? array_keys(array_filter($form_values['visibility'])) : $form_values['visibility'];
    }
  }
  else {
    $cache->display->content[$pane->pid]->visibility = '';
  }

  if (isset($form_values['access'])) {
    $cache->display->content[$pane->pid]->access = array_keys(array_filter($form_values['access']));
  }
  else {
    $cache->display->content[$pane->pid]->access = array();
  }

  $cache->display->content[$pane->pid]->configuration = $form_values['configuration'];

  // Call submit handlers specific to the $op ('add' or 'edit').
  $ajax_vars = call_user_func_array("panels_content_config_" . $op . "_form_submit", array($form_values, &$cache, $pane));
  $ajax_vars->id = $pane->pid;
  panels_cache_set($cache->display->did, $cache);
  return $ajax_vars;
}

Here is the call graph for this function:

panels_edit_cache_method_form	(	$	display,
		$	pid
	)

Choose cache method form

Definition at line 1217 of file display_edit.inc.

References panels_get_caches().

                                                       {
  $conf = $pid ? $display->content[$pid]->cache : $display->cache;

  // Set to 0 to ensure we get a selected radio.
  if (!isset($conf['method'])) {
    $conf['method'] = 0;
  }

  $caches = panels_get_caches();
  if (empty($caches)) {
    $form['markup'] = array('#value' => t('No caching options are available at this time. Please enable a panels caching module in order to use caching options.'));
    return $form;
  }

  $options[0] = t('No caching');
  foreach ($caches as $cache => $info) {
    $options[$cache] = check_plain($info['title']);
  }

  $form['method'] = array(
    '#prefix' => '<div class="no-float">',
    '#suffix' => '</div>',
    '#type' => 'radios',
    '#title' => t('Method'),
    '#options' => $options,
    '#default_value' => $conf['method'],
  );

  $form['submit'] = array(
    '#type' => 'submit',
    '#value' => t('Next'),
  );
  return $form;
}

Here is the call graph for this function:

panels_edit_cache_method_form_submit	(	$	form_id,
		$	form_values
	)

Submit callback for panels_edit_cache_method_form.

All this needs to do is return the method.

Definition at line 1258 of file display_edit.inc.

                                                                      {
  return $form_values['method'];
}

panels_edit_cache_settings_form	(	$	display,
		$	pid,
		$	method,
		$	settings_function
	)

Cache settings form

Definition at line 1314 of file display_edit.inc.

References panels_get_cache().

                                                                                      {
  $conf = $pid ? $display->content[$pid]->cache : $display->cache;
  $info = panels_get_cache($method);

  $form['description'] = array(
    '#prefix' => '<div class="description">',
    '#suffix' => '</div>',
    '#value' => check_plain($info['description']),
  );
  $form['settings'] = $settings_function($conf['settings'], $display, $pid);
  $form['settings']['#tree'] = TRUE;

  $form['method'] = array(
    '#type' => 'hidden',
    '#value' => $method,
  );

  $form['display'] = array(
    '#type' => 'value',
    '#value' => $display,
  );

  $form['pid'] = array(
    '#type' => 'value',
    '#value' => $pid,
  );

  $form['submit'] = array(
    '#type' => 'submit',
    '#value' => t('Save'),
  );
  return $form;
}

Here is the call graph for this function:

panels_edit_cache_settings_form_submit	(	$	form_id,
		$	form_values
	)

Allows panel styles to validate their style settings.

Definition at line 1361 of file display_edit.inc.

References panels_ajax_set_cache_data(), and panels_plugin_get_function().

                                                                        {
  if ($function = panels_plugin_get_function('cache', $form_values['method'], 'settings form submit')) {
    $function($form_values['settings']);
  }

  // Identify which configuration we're setting
  $pid = $form_values['pid'];
  $display = $form_values['display'];

  panels_ajax_set_cache_data($display, $pid, $form_values['method'], $form_values['settings']);
  return $display;
}

Here is the call graph for this function:

panels_edit_submit_subform

(

$

display

)

Definition at line 1377 of file display_edit.inc.

References panels_ajax_render(), and panels_get().

Referenced by panels_ajax().

                                              {
  // Check forms to make sure only valid forms can be rendered this way.
  $valid_forms = array('panels_add_content_config_form', 'panels_edit_pane_config_form');
  $form_id = $_POST['form_id'];
  if (!in_array($form_id, $valid_forms)) {
    return panels_ajax_render();
  }

  $output = drupal_get_form($form_id, $display);

  $next = panels_get('next');

  if ($next) {
    $output = drupal_get_form($next['form'], $display, $next['data']);
    $return = panels_get('return');
    if (!$return->output) {
      $return->output = $output;
    }
  }
  else {
    if (!($return = panels_get('return'))) {
      $return->type = 'display';
      $return->output = $output;
    }
    else if ($return->type == 'display' && !$return->output) {
      $return->output = $output;
    }
  }

  if ($return->type == 'display') {
    $return->output = theme('status_messages') . $return->output;
  }
  return $return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

panels_panel_settings

(

$

display

)

Form to edit panel style settings.

Definition at line 1419 of file display_edit.inc.

References panels_common_cache_get(), panels_common_cache_set(), panels_get_layout(), panels_get_panels(), panels_get_path(), panels_get_style(), and panels_get_styles().

Referenced by panels_edit_layout_settings_form().

                                         {
  $panel_settings = $display->panel_settings;
  $style = panels_get_style((!empty($panel_settings['style'])) ? $panel_settings['style'] : 'default');

  // Let the user choose between panel styles that are available for any
  // panels implementation or specifically to this one.
  $options = array();
  foreach (panels_get_styles() as $name => $properties) {
    if (empty($properties['hidden']) && (!empty($properties['render panel']))) {
      $options[$name] = $properties['title'];
    }
  }

  $form = array();

  $form['display'] = array('#type' => 'value', '#value' => $display);

  $form['panel_settings'] = array(
    '#type' => 'fieldset',
    '#title' => t('Panel settings'),
    '#tree' => TRUE,
  );

  $form['panel_settings']['start_box'] = array(
    '#value' => '<div class="form-item clear-block"><label>' . t('Default panel style') . ':</label>',
  );

  $modals = array();
  $form['panel_settings']['style'] = array(
    '#prefix' => '<div class="panels-style-settings-box">',
    '#suffix' => '</div>',
    '#type' => 'select',
    '#options' => $options,
    '#id' => 'panel-settings-style',
    '#default_value' => $style['name'],
  );

  // Is this form being posted? If so, check cache.
  if (!empty($_POST)) {
    $style_settings = panels_common_cache_get('style_settings', $display->did);
  }
  if (!isset($style_settings)) {
    $style_settings = !empty($panel_settings['style_settings']) ? $panel_settings['style_settings'] : array();
    panels_common_cache_set('style_settings', $display->did, $style_settings);
  }

  $form['panel_settings']['style_settings'] = array(
    '#type' => 'value',
    '#value' => $style_settings,
  );
  $form['panel_settings']['edit_style'] = array(
    '#type' => 'submit',
    '#id' => 'panels-style-settings',
    '#value' => t('Edit style settings'),
  );

  // Set up the AJAX settings for the modal.
  $modals['#panels-style-settings'] = array(url('panels/ajax/panel_settings/' . $display->did . '/default', NULL, NULL, TRUE), '#panel-settings-style');

  $form['panel_settings']['end_box'] = array(
    '#value' => '</div>',
  );

  $form['panel_settings']['individual'] = array(
    '#type' => 'checkbox',
    '#title' => t('Per panel settings'),
    '#id' => 'panel-settings-individual',
    '#description' => t('If this is checked, each region in the display can have its own style.'),
    '#default_value' => $panel_settings['individual'],
  );

  $layout_options = array_merge(array('-1' => t('Use the default panel style')), $options);
  $layout         = panels_get_layout($display->layout);
  $layout_panels  = panels_get_panels($layout, $display);

  $checkboxes = array();
  foreach ($layout_panels as $id => $name) {
    $form['panel_settings']['panel'][$id]['start_box'] = array(
      '#value' => '<div class="form-item clear-block"><label>' . $name . ':</label>',
    );
    $form['panel_settings']['panel'][$id]['style'] = array(
      '#prefix' => '<div class="panels-style-settings-box">',
      '#suffix' => '</div>',
      '#type' => 'select',
      '#options' => $layout_options,
      '#id' => 'panel-settings-style-' . $id,
      '#default_value' => $display->panel_settings['panel'][$id]['style'],
    );
    $checkboxes[] = '#panel-settings-style-' . $id;

    $form['panel_settings']['panel'][$id]['edit_style'] = array(
      '#type' => 'submit',
      '#id' => 'panels-style-settings-' . $id,
      '#attributes' => array('class' => 'panels-style-settings'),
      '#value' => t('Edit style settings'),
    );
    $checkboxes[] = '#panels-style-settings-' . $id;

    // Set up the AJAX settings for the modal.
    $modals['#panels-style-settings-' . $id ] = array(url('panels/ajax/panel_settings/' . $display->did . '/' . $id, NULL, NULL, TRUE), '#panel-settings-style-' . $id);

    $form['panel_settings']['panel'][$id]['end_box'] = array(
      '#value' => '</div>',
    );
  }

  // while we don't use this directly some of our forms do.
  drupal_add_js('misc/collapse.js');
  drupal_add_js('misc/autocomplete.js');

  $ajax = array('panels' => array(
    'closeText' => t('Close Window'),
    'closeImage' => theme('image', panels_get_path('images/icon-delete.png'), t('Close window'), t('Close window')),
    'throbber' => theme('image', panels_get_path('images/throbber.gif'), t('Loading...'), t('Loading')),
    'checkboxes' => array('#panel-settings-individual' => $checkboxes),
    'modals' => $modals,
  ));

  $form['panel_settings']['did'] = array(
    '#type' => 'value',
    '#value' => $display->did,
  );

  drupal_add_js(panels_get_path('js/lib/dimensions.js'));
  drupal_add_js(panels_get_path('js/lib/mc.js'));
  drupal_add_js(panels_get_path('js/lib/form.js'));
  drupal_add_js($ajax, 'setting');
  drupal_add_js(panels_get_path('js/checkboxes.js'));
  drupal_add_js(panels_get_path('js/modal_forms.js'));
  drupal_add_css(panels_get_path('css/panels_dnd.css'));

  return $form;
}

Here is the call graph for this function:

Here is the caller graph for this function:

panels_panel_settings_ajax	(	$	did,
		$	panel,
		$	name
	)

AJAX incoming to deal with the style settings modal

Definition at line 1571 of file display_edit.inc.

References panels_ajax_form(), panels_ajax_render(), panels_common_cache_get(), panels_common_cache_set(), and panels_get_style().

                                                         {
  if ($name == '0') {
    panels_ajax_render(t('There are no style settings to edit.'), t('Edit default style settings'));
  }

  $style = panels_get_style($name);
  $style_settings = panels_common_cache_get('style_settings', $did);
  if (!isset($style_settings)) {
    panels_ajax_render();
  }

  // Render the panels ajax form. This only returns to us on successful
  // submit; otherwise the form is rendered for us and nothing else happens.
  $style_settings[$panel] = panels_ajax_form('panels_common_style_settings_form',
    t('Edit style settings for @style', array('@style' => $style['title'])),
    url($_GET['q'], NULL, NULL, TRUE),
    $did, $style, $style_settings[$panel]
  );

  panels_common_cache_set('style_settings', $did, $style_settings);
  panels_ajax_render('dismiss');
}

Here is the call graph for this function: