Club Drupal

    }

  }

  // Re-index deltas after removing empty items.

  $submitted_values = array_values($submitted_values);

; We have to add a fake version so Git checkouts do not fail Media dependencies

version = 7.x-2.x-dev

core = "7.x"

project = "media"

package = Media

core = 7.x

dependencies[] = media

dependencies[] = multiform (>= 7.x-1.3)

dependencies[] = plupload

files[] = includes/MediaBrowserBulkUpload.inc

files[] = tests/media_bulk_upload.test

core = "7.x"

project = "media"

files[] = includes/MediaInternetValidationException.inc

files[] = tests/media_internet.test

core = "7.x"

project = "media"

files[] = includes/MediaInternetTestStreamWrapper.inc

files[] = includes/MediaInternetTestHandler.inc

core = "7.x"

project = "media"

configure = admin/structure/file-types/upgrade

core = "7.x"

project = "media"

            }

          }

        }

      }

      return Drupal.media.filter.syncAttributesToFields(file_info);

configure = admin/config/media/browser

core = "7.x"

project = "media"

package = Media

core = 7.x

core = "7.x"

project = "media"

core = 7.x

dependencies[] = media

core = "7.x"

project = "media"

files[] = includes/MediaModuleTest.inc

core = "7.x"

project = "media"

    secure pages doesn't know about. When trying to make non-secure ajax calls

    from a secure page, the browser denies the call.

  Solution:

Welcome to Panels 3

.dashboard-entry .dashboard-link {

  font-size: 120%;

  font-weight: bold;

div.panel-pane div.admin-links {

  font-size: xx-small;

  margin-right: 1em;

.layout-link {

  float: left;

  padding: 1em;

}

tr.changed td {

}

tr.changed td span.star {

  font-weight: bold;

}

td select {

#panels-dnd-main {

  margin: 0.5em 0;

}

}

/* Add Icon */

}

#panels-dnd-main div.panel-region .pane-add-link img {

  display: none;

}

.panel-portlet .changed div.grab-title {

  color: black !important;

}

.panel-portlet .changed.hidden-pane div.grab-title {

}

.panel-portlet .changed div.grab-title span.star {

  font-weight: bold;

}

.panel-portlet .grabber:hover {

  color: #fff;

}

.panel-portlet.hidden-pane .grab-title:hover {

  margin: 0;

}

  margin: 0;

  padding: 0;

  display: inline;

}

.panel-portlet .pane-title {

  cursor: pointer;

}

  padding-left: 1em;

  padding-bottom: 1em;

  margin-bottom: 1em;

}

.panels-section-columns {

.panels-section-column-categories .inside {

  padding: 0;

.panels-section-column-categories .content-type-button {

  padding-left: 10px;

  float: none;

}

  width: auto;

}

/* @group CTools Dropdown */

#panels-dnd-main .ctools-dropdown a.ctools-dropdown-text-link,

html.js div.panels-display-links a.ctools-dropdown-text-link {

  background: url('../images/arrow-down-light.png') 0 3px no-repeat!important;

  padding-left: 12px;

}

html.js #panels-dnd-main div.ctools-dropdown div.ctools-dropdown-container ul li,

html.js div.panels-display-links div.ctools-dropdown-container ul li {

  text-decoration: none;

  padding: 0;

  margin: 0;

html.js div.panels-display-links div.ctools-dropdown-container ul li .panels-sub-menu ul li a,

html.js #panels-dnd-main div.ctools-dropdown div.ctools-dropdown-container ul li .panels-sub-menu span.panels-text,

html.js div.panels-display-links div.ctools-dropdown-container ul li .panels-sub-menu span.panels-text {

  padding: 0 20px;

}

  top: -2em;

  margin-bottom: -2em;

}

div.panels-page-type-container {

  clear: left;

}

<?php

/**

 * @file

 */

/**

package = Multilingual - Internationalization

core = 7.x

core = "7.x"

project = "panels"

 *

 * This function must not rely on the passed $renderer parameter. The parameter

 * could be empty because this function is reused in i18n_ctools_render_alter().

 * @todo Check if a drupal_alter() in panels_display::get_title() is applicable.

 *

 * @see i18n_ctools_render_alter()

 *

 * Under some circumstances the title of the panel page is set before

 * hook_panels_pre_render() is fired. Such cases can be handled with this hook.

 * @todo Check if a drupal_alter() in panels_display::get_title() is applicable.

 */

function i18n_ctools_render_alter(&$info, $page, $context) {

 * Implements hook_ctools_plugin_post_alter().

 *

 * Register some translatable configuration settings for plugins.

 */

function i18n_panels_ctools_plugin_post_alter(&$plugin, $plugin_type_info) {

  if ($plugin_type_info['type'] == 'content_types') {

        if (empty($pane->uuid)) {

          // Fetch exported uuid and validate it.

          $uuid = str_replace('new-', '', $pane->pid);

            drupal_set_message(t('The pane %pane has no uuid, please resave or re-export it.', array('%pane' => $pane->pid)), 'warning');

            continue;

          }

 *

 * @todo I bet there are better ways to solve this mess.

 *

 *   Reset the static cache.

 *

 * @return array

<?php

/**

 * Minor menu callbacks for Panels helpers.

 */

    'description' => t('Custom layouts can add more, site-specific layouts that you can use in your panels.'),

  );

  ctools_include('export');

  $items = ctools_export_crud_load_all('panels_layout');

  $count = 0;

    $function($vars);

  }

  panels_dashboard_final_blocks($vars);

  // If page manager module is enabled, add a very low eight block to

    'class' => 'dashboard-create',

  );

  foreach ($vars['links'] as $link) {

    $vars['blocks']['links']['content'] .= theme('panels_dashboard_link', array('link' => $link));

  }

  $vars['left'] = '';

  $vars['right'] = '';

  foreach ($vars['blocks'] as $block) {

    $section = !empty($block['section']) ? $block['section'] : 'left';

    $vars[$section] .= theme('panels_dashboard_block', array('block' => $block));

  ctools_include('common', 'panels');

  return drupal_get_form('panels_common_settings', 'panels_page');

}

 *

 * @see panels_edit_layout()

 * @see _panels_edit_layout()

 */

class panels_allowed_layouts {

  /**

   *  allowed (TRUE) or disallowed (FALSE) for $this. Defaults to TRUE, which is more

   *  permissive but less of an administrative hassle if/when you add new layouts. Note

   *  that this parameter will be derived from $allowed_layouts if a value is passed in.

  var $allow_new = TRUE;

  /**

   *  variable_set($module_name . 'allowed_layouts', serialize($this)), thereby handling the

   *  storage of this object entirely within the Panels API. This object will be

   *  called and rebuilt by panels_edit_layout() if the same $module_name string is passed in

   *  for the $allowed_types parameter. \n

   *  This is primarily intended for convenience - client modules doing heavy-duty implementations

   *  of the Panels API will probably want to create their own storage method.

   * @see panels_edit_layout()

   */

  var $module_name = NULL;

  /**

   *  in the corresponding layout plugin definition), with value = 1 if the layout is

   *  allowed, and value = 0 if the layout is not allowed.

   *  Calling array_filter(panels_allowed_layouts::$allowed_layout_settings) will return an associative array

  /**

   * Constructor function; loads the $allowed_layout_settings array with initial values according

   *

   * @param bool $start_allowed

   */

  function __construct($start_allowed = TRUE) {

    foreach ($this->list_layouts() as $layout_name) {

      $this->allowed_layout_settings[$layout_name] = $start_allowed ? 1 : 0;

    }

   *      drupal_goto('</path/to/desired/redirect>');

   *    }

   *  }

   * @endcode \n

   *

   * If $allowed_layouts->form_state == 'failed-validate' || 'render', then you'll need to return

   * you to control where the user ends up next.

   *

   * @param string $title

   *

   * @return mixed $result

   *  - On the first passthrough when the form is being rendered, $result is the form's structured

  function set_allowed($title = 'Panels: Allowed Layouts') {

    $this->sync_with_available();

    $form_id = 'panels_common_set_allowed_layouts';

    $form = drupal_retrieve_form($form_id, $this, $title);

    if ($result = drupal_process_form($form_id, $form)) {

      $this->form_state = 'submit';

      return $result;

    }

   * If you don't serialize the second parameter of variable_get() and the variable name you provide

   * can't be found, an E_STRICT warning will be generated for trying to unserialize an entity

   * that has not been serialized.

   */

  function save() {

    if (!is_null($this->module_name)) {

    }

  }

    }

    return $layouts;

  }

}

/**

    // each type its own checkboxes set unless it's 'single' in which

    // case it can go into our fake other set.

    $available_content_types = ctools_content_get_all_types();

    foreach ($available_content_types as $id => $types) {

      foreach ($types as $type => $info) {

      '#tree' => TRUE,

    );

    $content_types['other'] = array('title' => t('Other'), 'weight' => 10);

    foreach ($content_types as $id => $info) {

      if (isset($allowed[$id])) {

}

/**

 */

function panels_common_settings_validate($form, &$form_state) {

  panels_common_allowed_layouts_form_validate($form, $form_state);

}

/**

 */

function panels_common_settings_submit($form, &$form_state) {

  panels_common_allowed_layouts_form_submit($form, $form_state);

  if (!$form_state['skip']) {

    // Merge the broken apart array neatly back together.

    $allowed_content_types = array();

      }

    }

  }

  drupal_set_message(t('Your changes have been saved.'));

}

 * Based upon the settings, get the allowed types for this node.

 */

function panels_common_get_allowed_types($module, $contexts = array(), $has_content = FALSE, $default_defaults = array(), $default_allowed_types = array()) {

  $default_types = variable_get($module . '_default', $default_defaults);

  // By default, if they haven't gone and done the initial setup here,

  // let all 'other' types (which will be all types) be available.

 * @ingroup forms

 *

 * @param array $allowed_layouts

 */

function panels_common_allowed_layouts_form(&$form, &$form_state, $module_name) {

  // Fetch our allowed layouts from variables.

  $form_state['allowed_layouts'] = &$allowed_layouts;

  ctools_add_js('layout', 'panels');

  $form['layout_selection'] = array(

 * Get the allowed layout object for the given module.

 */

function panels_common_get_allowed_layout_object($module_name) {

  if (!$allowed_layouts) {

    // are allowed.

    $allowed_layouts = new panels_allowed_layouts();

    $allowed_layouts->allow_new = TRUE;

    $allowed_layouts->module_name = $module_name;

  }

  $allowed_layouts->sync_with_available();

  return $allowed_layouts;

  if (empty($module_name)) {

    return $available_layouts;

  }

    $allowed_layouts = $module_name;

  }

  else {

    }

  }

  $layouts = array();

  asort($order);

  // We're doing these dependencies completely manualy, which is unusual, but

  // the process code only supports doing them in a form.

  // @todo modify dependent.inc to make this easier.

  $dependencies = array();

  foreach ($options as $category => $links) {

    $dependencies['panels-layout-category-' . $category] = array(

<?php

 * @file

 * Core Panels API include file containing various display-editing functions.

 * This includes all the basic editing forms (content, layout, layout settings)

}

/**

 *

 * No validation function is necessary, as all 'validation' is handled

 * either in the lead-up to form rendering (through the selection of

 * the ajax modals & content types.

 *

 * @ingroup forms

 * @see panels_edit_display_submit()

 */

function panels_edit_display_form($form, &$form_state) {

      $display->panels[$region_id] = array();

      if ($panes) {

        $pids = explode(',', $panes);

        foreach (array_filter($pids) as $pid) {

          if ($old_content[$pid]) {

            $display->panels[$region_id][] = $pid;

  ctools_include('dependent');

  if ($form_state['display_title']) {

      '#tree' => TRUE,

    );

      // We have to create a manual fieldset because fieldsets do not support IDs.

      // Use 'hidden' instead of 'markup' so that the process will run.

      // Add js for collapsible fieldsets manually

      $rows = array();

      foreach ($display->context as $context) {

        foreach (ctools_context_get_converters('%' . check_plain($context->keyword) . ':', $context) as $keyword => $title) {

        '#collapsible' => TRUE,

        '#collapsed' => TRUE,

        '#value' => theme('table', array('header' => $header, 'rows' => $rows)),

      );

    }

  }

  if (!empty($layout['settings form']) && function_exists($layout['settings form'])) {

    $form['layout_settings'] = $layout['settings form']($display, $layout, $display->layout_settings);

  }

/**

 * @file

 * Handle the forms for changing a display's layout.

 */

  if (empty($_POST) || empty($_POST['form_id']) || $_POST['form_id'] != 'panels_change_layout') {

    $output = drupal_build_form('panels_choose_layout', $form_state);

    if (!empty($form_state['executed'])) {

      $change_form_state['layout'] = $_SESSION['layout'][$display->did] = $form_state['layout'];

      $change_form = TRUE;

    }

  $js['CTools']['dependent'] = $dependencies;

  drupal_add_js($js, 'setting');

  if (empty($form_state['no buttons'])) {

    $form['submit'] = array(

      '#type' => 'submit',

    foreach ($form_state['values']['panel']['pane'] as $region_id => $panes) {

      if ($panes) {

        $pids = explode(',', $panes);

        foreach (array_filter($pids) as $pid) {

          $switch[$pid] = $region_id;

        }

<?php

/**

 * Legacy state manager for Panels.

 *

 * Checks all possible ways (using discovery of patterned method names) in which

 * Panels may need to operate in legacy mode,

 */

class PanelsLegacyState {

  var $legacy = NULL;

  function t() {

    $func = get_t();

    $args = func_get_args();

    return call_user_func_array($func, $args);

  }

  function getStatus() {

    if (!isset($this->legacy)) {

      $this->determineStatus();

   */

  function determineStatus() {

    $this->legacy = array();

      if (strtolower(substr($method, 0, 5)) == 'check') {

        $this->legacy[$method] = $this->$method();

      }

    $this->legacy = array_filter($this->legacy);

  }

}

    '#value' => '</fieldset>',

  );

}

/**

  // Panels provides this caching mechanism to make it easy to use the

  // wizard to cache the display.

  $cache = panels_edit_cache_get('panels_page_wizard:' . $form_state['plugin']['name']);

  $form_state['renderer'] = panels_get_renderer_handler('editor', $cache->display);

}

/**

 *

 * This is not a proper submit handler, it is meant to be called by a form's

 * submit handler to handle submission.

 */

function panels_page_wizard_add_content_submit(&$form, &$form_state) {

  // Call the normal panels edit form submit to make sure values are stored

  panels_edit_display_form_submit($form, $form_state);

  $cache = &$form_state['wizard cache'];

  $cache->display = &$form_state['display'];

  unset($cache->display_cache);

}

function panels_default_panels_renderer_pipeline() {

  $pipelines = array();

  $pipeline->disabled = FALSE; /* Edit this to true to make a default pipeline disabled initially */

  $pipeline->api_version = 1;

  $pipeline->name = 'standard';

/**

 * @file

 * Contains helper code for plugins and contexts.

 */

 *   The cached content, or FALSE to indicate no cached content exists.

 */

function panels_get_cached_content($display, $args, $context, $pane = NULL) {

  if (!empty($_POST)) {

    return FALSE;

  }

    return FALSE;

  }

  $cache->restore();

  return $cache;

}

 * Store cached content for a given display and possibly pane.

 */

function panels_set_cached_content($cache, $display, $args, $context, $pane = NULL) {

  if (!empty($_POST)) {

    return FALSE;

  }

  $conf = $pane ? $pane->cache['settings'] : $display->cache['settings'];

  $cache->cache();

  return $function($conf, $cache, $display, $args, $context, $pane);

}

    $this->ready = TRUE;

    $this->head = str_replace($this->head, '', drupal_add_html_head());

    // Slightly less simple for CSS:

      }

    }

  }

}

/**

 * Choose a renderer for a display based on a render pipeline setting.

 */

function panels_get_renderer($pipeline_name, &$display) {

  ctools_include('export');

  $pipeline = ctools_export_crud_load('panels_renderer_pipeline', $pipeline_name);

    return $renderer;

  }

  return panels_get_renderer_handler('standard', $display);

}

 */

function _panels_renderer_pipeline_sort($a, $b) {

  if ($a->weight == $b->weight) {

    return ($a->admin_title < $b->admin_title) ? -1 : 1;

  }

  return ($a->weight < $b->weight) ? -1 : 1;

 * @param string $argument

 *   The second half of the cache key. Full key module:TASK_NAME:HANDLER_NAME

 *   passed part: TASK_NAME:HANDLER_NAME

 *   The display to cache.

 */

function hook_panels_cache_set($argument, $cache) {

 * @param string $argument

 *   The second half of the cache key. Full key module:TASK_NAME:HANDLER_NAME

 *   passed part: TASK_NAME:HANDLER_NAME

 *   The display to cache.

 *

 * @return stdClass

 * @param string $argument

 *   The second half of the cache key. Full key module:TASK_NAME:HANDLER_NAME

 *   passed part: TASK_NAME:HANDLER_NAME

 *   The cached display.

 */

function hook_panels_cache_clear($argument, $cache) {

 *

 * This happens after the keyword substitution.

 *

 *   The content block to render.

 *   The pane object.

 * @param array $args

 *   The display arguments.

 * @param string $argument

 *   The second half of the cache key. Full key module:TASK_NAME:HANDLER_NAME

 *   passed part: TASK_NAME:HANDLER_NAME

 *   The cached display.

 */

function hook_panels_edit_cache_break_lock($argument, $cache) {

 *

 * @param panels_display $panels_display

 *   The panels display that will be rendered.

 *   The renderer object that will be used to render.

 *

 * @return string

 *

 * @param panels_display $panels_display

 *   The rendered panels display.

 *   The used renderer object.

 *

 * @return string

/**

 * Fired before a new pane is inserted in the storage.

 *

 *   Pane that will be rendered.

 */

function hook_panels_pane_insert($pane) {

/**

 * Fired before a changed pane is updated in the storage.

 *

 *   Pane that will be rendered.

 */

function hook_panels_pane_update($pane) {

 * Last chance to modify the pane before the keyword substitution runs and the

 * pane is rendered.

 *

 *   Pane that will be rendered.

 */

function hook_panels_pane_prerender($pane) {

/**

 * Fired before a display is deleted.

 *

 *   Id of the display to delete.

 */

function hook_panels_delete_display($did) {

files[] = tests/PanelsTermViewWebTestCase.test

files[] = tests/PanelsUserViewWebTestCase.test

core = "7.x"

project = "panels"

<?php

/**

 * Test requirements for installation and running.

 */

  );

  return $schema;

function panels_schema_8() {

  $schema = panels_schema_7();

    ),

    'primary key' => array('pid'),

    'indexes' => array(

    ),

  );

 */

function panels_update_7301() {

  // Load the schema.

  // Due to a previous failure, the field may already exist:

  $schema = panels_schema_4();

  $table = 'panels_pane';

  $field = 'locks';

  }

  if (!empty($page_manager_panels)) {

    $result = db_query("SELECT pd.did FROM {panels_display} pd WHERE pd.did IN (:dids) AND storage_type = ''", array(':dids' => array_keys($page_manager_panels)));

    foreach ($result as $row) {

      db_update('panels_display')

    db_create_table($table_name, $schema[$table_name]);

  }

}

/**

<?php

/**

 * Core functionality for the Panels engine.

 */

define('PANELS_VERSION', '7.x-3.8');

/**

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

 *

 * @todo -- this should work more like the CTools API version.

 *

 */

function panels_api_version() {

  return array(3, 1);

}

/**

 */

function panels_theme() {

  // Safety: go away if CTools is not at an appropriate version.

  $theme = array();

  $theme['panels_layout_link'] = array(

  );

  $theme['panels_layout_icon'] = array(

  );

  $theme['panels_pane'] = array(

    'path' => drupal_get_path('module', 'panels') . '/templates',

    'template' => 'panels-pane',

  );

  );

  $theme['panels_add_content_modal'] = array(

    'path' => drupal_get_path('module', 'panels') . '/templates',

    'file' => '../includes/add-content.inc',

    'template' => 'panels-add-content-modal',

  );

  $theme['panels_add_content_link'] = array(

    'path' => drupal_get_path('module', 'panels') . '/templates',

    'file' => '../includes/add-content.inc',

    'template' => 'panels-add-content-link',

  );

  // Register layout and style themes on behalf of all of these items.

  ctools_include('plugins', 'panels');

    foreach (array('theme', 'admin theme') as $callback) {

      if (!empty($data[$callback])) {

        $theme[$data[$callback]] = array(

          'path' => $data['path'],

          'file' => $data['file'],

        );

        if (!function_exists("theme_$data[theme]")) {

          $theme[$data[$callback]]['template'] = str_replace('_', '-', $data[$callback]);

        }

      }

    }