/ - Diff - Club Drupal - Forge Centrale Marseille

     This module provides by default the ability to translate panel display and
     panel pane titles.
     Further it introduced an extension to the ctools content_types plugin.
     You can now define translatable settings which will be registered in i18n.
     Out of the box the module extends the custom content content_type to allow
     translation of the content.
     Requirements:
        Ctools 7.x-1.x-dev (Jan 28-2014 or newer)
        Panels 7.x-3.x-dev (Jan 28-2014 or newer)
     Plugin definition extension:
     ------------------------------
     This example shows how the content_type custom is extended:
     #### Default: ####
     /**
      * Plugins are described by creating a $plugin array which will be used
      * by the system that includes this file.
      */
     $plugin = array(
       'title' => t('Custom content'),
       'no title override' => TRUE,
       'defaults' => array('admin_title' => '', 'title' => '', 'body' => '', 'format' => filter_fallback_format(), 'substitute' => TRUE),
       'js' => array('misc/autocomplete.js', 'misc/textarea.js', 'misc/collapse.js'),
       // Make sure the edit form is only used for some subtypes.
       'edit form' => '',
       'add form' => '',
       'edit text' => t('Edit'),
       'all contexts' => TRUE,
     );
     #### Extended Configuration: ####
     /**
      * Plugins are described by creating a $plugin array which will be used
      * by the system that includes this file.
      */
     $plugin = array(
       'title' => t('Custom content'),
       'no title override' => TRUE,
       'defaults' => array('admin_title' => '', 'title' => '', 'body' => '', 'format' => filter_fallback_format(), 'substitute' => TRUE),
       'js' => array('misc/autocomplete.js', 'misc/textarea.js', 'misc/collapse.js'),
       // Make sure the edit form is only used for some subtypes.
       'edit form' => '',
       'add form' => '',
       'edit text' => t('Edit'),
       'all contexts' => TRUE,
       'i18n_settings' = array(
         'title',
         'body' => array('format' => 'plain_text'),
         'items|0|title'
       ),
     );
     The new key "i18n_settings" defines an array with the settings that are
     translatable. The array contains the names of the settings, they have to be
     available in the "defaults" array of the content definition. If you need to
     define a format use the name of the setting as the array item key and as item
     another array with the detail configuration. E.g
     'i18n_settings' = array('body' => array('format' => 'plain_text'))
     If i18n_settings is a string it's used as callback. The expected return is an
     array equal to the one used in the fix configuration.
     You can even declare nested settings  as translatable, to do so use '|' as
     delimiter.
     E.g. 'items|0|title' is evaluated as $settings['items'][0]['title']
     #### Callback: ####
     /**
      * Plugins are described by creating a $plugin array which will be used
      * by the system that includes this file.
      */
     $plugin = array(
       'title' => t('Custom content'),
       'no title override' => TRUE,
       'defaults' => array('admin_title' => '', 'title' => '', 'body' => '', 'format' => filter_fallback_format(), 'substitute' => TRUE),
       'js' => array('misc/autocomplete.js', 'misc/textarea.js', 'misc/collapse.js'),
       // Make sure the edit form is only used for some subtypes.
       'edit form' => '',
       'add form' => '',
       'edit text' => t('Edit'),
       'all contexts' => TRUE,
       'i18n_settings' => 'ctools_custom_content_type_i18n_settings',
     );
     function ctools_custom_content_type_i18n_settings($conf) {
       return array(
         'title',
         'body' => array('format' => $conf['format']),
       );
+    }

     <?php
     /**
      * @file
      * Internationalization (i18n) hooks
      */
     /**
      * Implements hook_i18n_object_info().
      */
     function i18n_panels_i18n_object_info() {
       $info['pane_configuration'] = array(
         'title' => t('Pane Configuration'),
         'key' => 'uuid',
         'string translation' => array(
           'textgroup' => 'panels',
           'type' => 'pane_configuration',
           'properties' => array(
             'title' => t('Pane Title'),
           ),
         ),
       );
       $info['display_configuration'] = array(
         'title' => t('Display Configuration'),
         'key' => 'uuid',
         'string translation' => array(
           'textgroup' => 'panels',
           'type' => 'display_configuration',
           'properties' => array(
             'title' => t('Display Title'),
           ),
         ),
       );
       return $info;
+    }
     /**
      * Implements hook_i18n_string_info().
      */
     function i18n_panels_i18n_string_info() {
       $groups['panels'] = array(
         'title' => t('Panels'),
         'description' => t('Translatable panels items: display and pane configuration items. E.g. Title.'),
         // This group doesn't have strings with format.
         'format' => FALSE,
         // This group can list all strings.
         'list' => FALSE,
       );
       return $groups;
+    }

     name = Panels translation
     description = Supports translatable panels items.
     dependencies[] = i18n
     dependencies[] = panels
     dependencies[] = i18n_string
     dependencies[] = i18n_translation
     package = Multilingual - Internationalization
     core = 7.x
     ; Information added by Drupal.org packaging script on 2014-02-12
     version = "7.x-3.4"
     core = "7.x"
     project = "panels"
     datestamp = "1392221614"

     <?php
     /**
      * @file
      * Internationalization (i18n) submodule: Panels translation.
      */
     /**
      * Implements hook_requirements().
      */
     function i18n_panels_requirements($phase) {
       $requirements = array();
       // Check only for status report, to allow update / install.
       if ($phase == 'runtime') {
         // Check if the panels module runs with uuids.
         $requirements['uuid'] = array(
           'title' => t('Panels uuid support.'),
           'severity' => REQUIREMENT_OK,
           'value' => t('Available'),
         );
         if (!db_field_exists('panels_pane', 'uuid')) {
           $requirements['uuid']['severity'] = REQUIREMENT_ERROR;
           $requirements['uuid']['value'] = t('Not found. Please apply the provided patches and run the update script.');
+        }
+      }
       return $requirements;
+    }

     <?php
     /**
      * @file
      * Internationalization (i18n) submodule: Panels translation.
      */
     /**
      * Fetch the i18n_settings of the content type if there are any.
+     *
      * @param stdClass $pane
      *   The pane to deal with.
+     *
      * @return array|false
      *   Settings or FALSE if none are present.
      */
     function i18n_panels_get_i18n_settings($pane) {
       ctools_include('content');
       $content_type = ctools_get_content_type($pane->type);
       if (isset($content_type['i18n_settings'])) {
         if (is_string($content_type['i18n_settings']) && function_exists($content_type['i18n_settings'])) {
           $content_type['i18n_settings'] = $content_type['i18n_settings']($pane->configuration);
+        }
+      }
       // Provide the override title string as translation for all panes that have
       // this setting enabled.
       if (isset($pane->configuration['override_title']) && $pane->configuration['override_title']) {
         if (isset($content_type['i18n_settings']) && is_array($content_type['i18n_settings'])) {
           $content_type['i18n_settings'][] = 'override_title_text';
+        }
         else {
           $content_type['i18n_settings'] = array('override_title_text');
+        }
+      }
       return isset($content_type['i18n_settings']) ? $content_type['i18n_settings'] : FALSE;
+    }
     /**
      * Returns the translation object of the pane.
+     *
      * @param stdClass $pane
      *   The pane to deal with.
+     *
      * @return stdClass|FALSE
      *   Returns FALSE if no translation is necessary.
      */
     function i18n_panels_get_i18n_translation_object($pane) {
       $translation_object = array();
       // Handle content type specific i18n settings.
       if ($i18n_settings = i18n_panels_get_i18n_settings($pane)) {
         // Register translatable settings.
         foreach ($i18n_settings as $i18n_setting => $settings) {
           if (!is_array($settings)) {
             $i18n_setting = $settings;
             $settings = array('format' => 'plain_text');
+          }
           $translation_object[$i18n_setting] = NULL;
           $key_exists = FALSE;
           // Ensure a nested setting is "unpacked".
           $config_value = drupal_array_get_nested_value($pane->configuration, explode('|', $i18n_setting), $key_exists);
           // If we reached the end of the nested setting use the value as source.
           if ($key_exists) {
             $translation_object[$i18n_setting] = array(
               'string' => $config_value,
               'format' => $settings['format'],
             );
             $translation_object['panels_i18n_settings'][$i18n_setting] = $settings;
+          }
+        }
+      }
       // Check if this pane has a custom title enabled.
       if (!empty($pane->configuration['override_title'])) {
         $translation_object['title']['string'] = $pane->configuration['override_title_text'];
+      }
       if (!empty($translation_object)) {
         return (object) $translation_object;
+      }
       return FALSE;
+    }
     /**
      * Implements hook_panels_pane_insert().
+     *
      * @param stdClass $pane
      *   The pane to deal with.
      */
     function i18n_panels_panels_pane_insert($pane) {
       i18n_panels_panels_pane_update($pane);
+    }
     /**
      * Implements hook_panels_pane_update().
+     *
      * @param stdClass $pane
      *   The pane to deal with.
      */
     function i18n_panels_panels_pane_update($pane) {
       if ($translation_object = i18n_panels_get_i18n_translation_object($pane)) {
         $translation_object->uuid = $pane->uuid;
         $status = i18n_string_object_update('pane_configuration', $translation_object);
+      }
+    }
     /**
      * Implements hook_panels_pane_delete().
+     *
      * @param array $pids
      *   Array with the panel ids to delete.
      */
     function i18n_panels_panels_pane_delete($pids) {
       if (!empty($pids)) {
         // Fetch the uuids from the db.
         $uuids = db_select('panels_pane')
           ->fields('panels_pane', array('uuid'))
           ->condition('pid', $pids)
           ->execute()
           ->fetchCol();
         foreach ($uuids as $uuid) {
           // Create dummy pane with uuid as property.
           $pane = (object) array('uuid' => $uuid);
           i18n_string_object_remove('pane_configuration', $pane);
+        }
+      }
+    }
     /**
      * Implements hook_panels_pane_prerender().
+     *
      * @param stdClass $pane
      *   The pane to deal with.
      */
     function i18n_panels_panels_pane_prerender($pane) {
       // Check if this pane has translations.
       if (isset($pane->uuid) && $translation_object = i18n_panels_get_i18n_translation_object($pane)) {
         $translation_object->uuid = $pane->uuid;
         // Send to translation.
         $translation_object = i18n_string_object_translate('pane_configuration', $translation_object);
         unset($translation_object->uuid, $translation_object->i18n_settings);
         foreach ($translation_object as $i18n_setting => $translated_setting) {
           if ($i18n_setting != 'panels_i18n_settings') {
             if (is_array($translated_setting)) {
               $translated_setting = $translated_setting['string'];
+            }
             drupal_array_set_nested_value($pane->configuration, explode('|', $i18n_setting), $translated_setting);
+          }
+        }
+      }
+    }
     /**
      * Implements hook_panels_display_save().
+     *
      * @param panels_display $display
      *   The display to deal with.
      */
     function i18n_panels_panels_display_save($display) {
       $status = i18n_string_object_update('display_configuration', $display);
+    }
     /**
      * Implements hook_panels_display_delete().
+     *
      * @param int $did
      *   Id of the display to delete.
      */
     function i18n_panels_panels_delete_display($did) {
       // Fetch uuid to delete the translations.
       $uuid = db_select('panels_display')
         ->fields('panels_display', array('uuid'))
         ->condition('did', $did)
         ->execute()
         ->fetchColumn();
       // Build a dummy display.
       $display = (object) array('uuid' => $uuid);
       // Check if this display was just saved in the db.
       if (!_18n_panels_is_exported_panels_display($display)) {
         // If the display was just saved in the db remove all translations.
         i18n_string_object_remove('display_configuration', $display);
         // Remove related pane translations too.
         $pids = db_select('panels_pane')
           ->fields('panels_pane', array('pid'))
           ->condition('did', $did)
           ->execute()
           ->fetchCol();
         i18n_panels_panels_pane_delete($pids);
+      }
       else {
         // If the display is exported leave the translated strings but give the user
         // a hint how to clean up.
         drupal_set_message(
           t(
             'The reverted panels display(s) were exported, please run a <a href="!link">string refresh</a> to update the translatable strings.',
             array('!link' => url('admin/config/regional/translate/i18n_string'))
           ),
           'warning',
           FALSE
         );
+      }
+    }
     /**
      * Implements hook_panels_pre_render().
+     *
      * 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()
+     *
      * @param panels_display $display
      *   The display to deal with.
      * @param panels_renderer_standard $renderer
      *   The renderer to deal with.
      */
     function i18n_panels_panels_pre_render(&$display, $renderer) {
       // Avoid double translations.
       if (!isset($display->i18n_panels_title_translated)) {
         $translation = i18n_string_object_translate('display_configuration', $display);
         if (is_array($translation->title)) {
           $display->title = $translation->title['string'];
+        }
         else {
           $display->title = $translation->title;
+        }
         $display->i18n_panels_title_translated = TRUE;
+      }
+    }
     /**
      * Implements hook_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) {
       // @todo Find a better way to detect a panels page.
       if ($page === TRUE && !empty($info['content']['#display']) && $info['content']['#display'] instanceof panels_display) {
         i18n_panels_panels_pre_render($info['content']['#display'], NULL);
         // Set the info title. This is used to set the page title.
         $info['title'] = $info['content']['#display']->get_title();
+      }
+    }
     /**
      * 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') {
         // Modify custom content.
         if ($plugin['name'] == 'custom') {
           // Register callback to get the translatable settings.
           $plugin['i18n_settings'] = 'ctools_custom_content_type_i18n_settings';
+        }
+      }
+    }
     /**
      * Callback to provide the translatable settings appropriate to the config.
+     *
      * @param array $conf
      *   Content type configuration.
+     *
      * @return array
      *   i18n_settings configuration.
      */
     function ctools_custom_content_type_i18n_settings($conf) {
       return array(
         'title',
         'body' => array('format' => $conf['format']),
       );
+    }
     /**
      * Implements hook_i18n_string_list_TEXTGROUP_alter().
+     *
      * Necessary to support the dynamic translatable settings defined by ctools
      * content types.
      */
     function i18n_panels_i18n_string_list_panels_alter(&$strings, $type = NULL, $object = NULL) {
       if (isset($object->panels_i18n_settings)) {
         foreach ($object->panels_i18n_settings as $i18n_setting => $settings) {
           if (isset($object->{$i18n_setting})) {
             $strings['panels'][$type][$object->uuid][$i18n_setting] = $object->{$i18n_setting};
+          }
+        }
+      }
+    }
     /**
      * Implements hook_i18n_string_list().
+     *
      * @todo Figure out a generic solution to fetch exported displays.
      */
     function i18n_panels_i18n_string_list($group) {
       $strings = array();
       if ($group == 'panels') {
         // Fetch all available displays.
         $displays = _18n_panels_fetch_all_panel_displays();
         foreach ($displays as $display) {
           if (empty($display->uuid)) {
             drupal_set_message(t('The display %display has no uuid, please resave or re-export it.', array('%display' => $display->did)), 'warning');
             continue;
+          }
           // Avoid duplicated runs _18n_panels_fetch_all_panel_displays() probably
           // returns the same display twice, one for the db based and one for the
           // exported one.
           if (isset($strings['panels']['display_configuration'][$display->uuid])) {
             continue;
+          }
           $strings['panels']['display_configuration'][$display->uuid]['title']['string'] = $display->title;
           foreach ($display->content as $pane) {
             if (empty($pane->uuid)) {
               // Fetch exported uuid and validate it.
               $uuid = str_replace('new-', '', $pane->pid);
               if (!panels_uuid_is_valid($uuid)) {
                 drupal_set_message(t('The pane %pane has no uuid, please resave or re-export it.', array('%pane' => $pane->pid)), 'warning');
                 continue;
+              }
               $pane->uuid = $uuid;
+            }
             if ($translation_object = i18n_panels_get_i18n_translation_object($pane)) {
               // Split up all strings and add them to the list.
               $pane_strings = (array) $translation_object;
               unset($pane_strings['panels_i18n_settings']);
               foreach ($pane_strings as $key => $pane_string) {
                 $strings['panels']['pane_configuration'][$pane->uuid][$key] = $pane_string;
+              }
+            }
+          }
+        }
+      }
       return $strings;
+    }
     /**
      * Checks if the give display is exported or only stored in the db.
+     *
      * @return boolean
      *   TRUE if the display is available from code.
      */
     function _18n_panels_is_exported_panels_display($display) {
       if (isset($display->uuid)) {
         $displays = _18n_panels_fetch_all_panel_displays();
         return isset($displays['exported-' . $display->uuid]);
+      }
       return FALSE;
+    }
     /**
      * Returns a list of really all available panel displays.
+     *
      * The list is statically cached. Use the parameter $reset to refresh the list
      * during the same request.
      * Probably returns the same display twice - once with the db based and once
      * the exported one.
+     *
      * @todo I bet there are better ways to solve this mess.
+     *
      * @param boolean $reset
      *   Reset the static cache.
+     *
      * @return array
      *   List of all panel displays.
      */
     function _18n_panels_fetch_all_panel_displays($reset = FALSE) {
       $displays = &drupal_static(__FUNCTION__, array());
       if (!empty($displays) && !$reset) {
         return $displays;
+      }
       // Fetch db based displays.
       $dids = db_select('panels_display')->fields('panels_display', array('did'))->execute()->fetchCol();
       $displays = panels_load_displays($dids);
       // Fetch exported displays.
       ctools_include('export');
       foreach (ctools_export_crud_load_all('panels_display') as $panels_display) {
         if (!empty($panels_display->uuid)) {
           $displays['exported-' . $panels_display->uuid] = $panels_display;
+        }
+      }
       // Fetch mini panels.
       $mini_panels = ctools_export_crud_load_all('panels_mini');
       foreach ($mini_panels as $pane) {
         if (!empty($pane->display->uuid)) {
           $displays['exported-' . $pane->display->uuid] = $pane->display;
+        }
+      }
       // Fetch in page manager embedded displays.
       if (module_exists('page_manager')) {
         module_load_include('inc', 'page_manager', 'page_manager.admin');
         $tasks = page_manager_get_tasks_by_type('page');
         $pages = array('operations' => array(), 'tasks' => array());
         page_manager_get_pages($tasks, $pages);
         foreach ($pages['tasks'] as $task) {
           $page = page_manager_cache_load($task);
           $task_info = page_manager_get_task_subtasks($page->task);
           foreach ($page->handler_info as $id => $info) {
             $page_manager_handler = $page->handlers[$id];
             if ($page_manager_handler->handler == 'panel_context') {
               // @todo Is there really no better way to check this?
               $is_exported = ($page_manager_handler->export_type == (EXPORT_IN_CODE | EXPORT_IN_DATABASE) || (isset($page->subtask['storage']) && $page->subtask['storage'] == t('Overridden')));
               if (!empty($page_manager_handler->conf['display'])) {
                 $panels_display = $page_manager_handler->conf['display'];
                 $displays['exported-' . $panels_display->uuid] = $panels_display;
+              }
               elseif ($is_exported && isset($page_manager_handler->conf['did'])) {
                 $panels_display = panels_load_display($page_manager_handler->conf['did']);
                 if (isset($panels_display->uuid)) {
                   $displays['exported-' . $panels_display->uuid] = $panels_display;
+                }
+              }
+            }
+          }
+        }
+      }
       // Fetch panelizer displays.
       if (module_exists('panelizer')) {
         // Fetch all default handlers.
         $panelizer_defaults = ctools_export_crud_load_all('panelizer_defaults');
         foreach ($panelizer_defaults as $panelizer_default) {
           $displays['exported-' . $panelizer_default->display->uuid] = $panelizer_default->display;
+        }
+      }
       return $displays;
+    }

+        }
+      }
       ctools_include('plugins', 'panels');
       $pipelines = panels_get_renderer_pipelines();
       $options = array();
       foreach ($pipelines as $key => $value) {
         $options[$key] = $value->admin_title;
+      }
       if (count($options) > 1) {
         $form['panels_renderer_default'] = array(
           '#type' => 'select',
           '#title' => t('Default renderer'),
           '#options' => $options,
           '#default_value' => variable_get('panels_renderer_default', 'standard'),
           '#description' => t('The default renderer for new panel pages.'),
         );
+      }
       if (empty($form)) {
         return array('#value' => t('There are currently no settings to change, but additional plugins or modules may provide them in the future.'));
+      }

drupal7/sites/all/modules/panels/includes/common.inc
477	477	* Get the allowed layouts for the given module.
478	478	*/
479	479	function panels_common_get_allowed_layouts($module_name) {
	480	ctools_include('plugins', 'panels');
480	481	$available_layouts = panels_get_layouts();
481	482	if (empty($module_name)) {
482	483	return $available_layouts;

         $start = $this->js;
         $this->js = array();
         // Use the advanced mapping function from Drupal >= 7.23 if available.
         $array_mapping_func = function_exists('drupal_array_diff_assoc_recursive') ? 'drupal_array_diff_assoc_recursive' : 'array_diff_assoc';
         // If there are any differences between the old and the new javascript then
         // store them to be added later.
         if ($diff = array_diff_assoc($js, $start)) {
           $this->js = $diff;
+        }
         // Special case the settings key and get the difference of the data.
         if ($settings_diff = array_diff_assoc($js['settings']['data'], $start['settings']['data'])) {
           $this->js['settings'] = $settings_diff;
         if ($diff = $array_mapping_func($js, $start)) {
           // Iterate over the diff to ensure we keep the keys on merge and don't add
           // unnecessary items.
           foreach ($diff as $key => $diff_data) {
             // Special case the settings key and get the difference of the data.
             if ($key === 'settings') {
               // Iterate over the diff to ensure we keep the keys on merge and don't
               // add unnecessary items.
               if (isset($diff[$key]['data'])) {
                 foreach ($diff[$key]['data'] as $settings_key => $settings_data) {
                   // Merge the changes with the base to get a complete settings
                   // array.
                   $this->js[$key]['data'][] = drupal_array_merge_deep($settings_data, $diff[$key]['data'][$settings_key]);
+                }
+              }
+            }
             else {
               $this->js[$key] = $diff_data;
               // Check if the key was present already and if so merge the changes
               // with the original data to get the full settings array.
               if (isset($start[$key])) {
                 $this->js[$key] = drupal_array_merge_deep($start[$key], $this->js[$key]);
+              }
+            }
+          }
+        }
         // And for tokens:
-...
               drupal_add_js($args['data'], $args);
+            }
             else {
               foreach ($args as $setting) {
               foreach ($args['data'] as $setting) {
                 drupal_add_js($setting, 'setting');
+              }
+            }

       $('a.pane-delete:not(.pane-delete-processed)', context)
         .addClass('pane-delete-processed')
         .click(function() {
         if (confirm('Remove this pane?')) {
         if (confirm(Drupal.t('Remove this pane?'))) {
           var id = '#' + $(this).attr('id').replace('pane-delete-', '');
           $(id).remove();
           Drupal.Panels.Draggable.savePositions();

     (function ($) {
       Drupal.Panels = Drupal.Panels || {};
       Drupal.Panels.autoAttach = function() {
         if ($.browser.msie) {
           // If IE, attach a hover event so we can see our admin links.
           $("div.panel-pane").hover(
             function() {
               $('div.panel-hide', this).addClass("panel-hide-hover"); return true;
             },
             function() {
               $('div.panel-hide', this).removeClass("panel-hide-hover"); return true;
+            }
           );
           $("div.admin-links").hover(
             function() {
               $(this).addClass("admin-links-hover"); return true;
             },
             function(){
               $(this).removeClass("admin-links-hover"); return true;
+            }
           );
+        }
       };
       $(Drupal.Panels.autoAttach);
     })(jQuery);

     <?php
     /**
      * @file
      * Hooks provided by Panels.
      */
     /**
      * Allow modules to provide their own caching mechanism for the display editor.
+     *
      * @param string $argument
      *   The second half of the cache key. Full key module:TASK_NAME:HANDLER_NAME
      *   passed part: TASK_NAME:HANDLER_NAME
      * @param stdClass $cache
      *   The display to cache.
      */
     function hook_panels_cache_set($argument, $cache) {
       list($handler, $item) = _panels_mini_panels_cache_get($argument);
       $item->mini_panels_display_cache = $cache;
       $handler->edit_cache_set_key($item, $argument);
+    }
     /**
      * Allow modules to provide their own caching mechanism for the display editor.
+     *
      * @param string $argument
      *   The second half of the cache key. Full key module:TASK_NAME:HANDLER_NAME
      *   passed part: TASK_NAME:HANDLER_NAME
+     *
      * @return stdClass|NULL
      *   The cached display or NULL if the cache wasn't hit.
      */
     function hook_panels_cache_get($argument) {
       ctools_include('common', 'panels');
       list($handler, $item) = _panels_mini_panels_cache_get($argument);
       if (isset($item->mini_panels_display_cache)) {
         return $item->mini_panels_display_cache;
+      }
       $cache = new stdClass();
       $cache->display = $item->display;
       $cache->display->context = ctools_context_load_contexts($item);
       $cache->display->cache_key = 'panels_mini:' . $argument;
       $cache->content_types = panels_common_get_allowed_types('panels_mini', $cache->display->context);
       $cache->display_title = TRUE;
       // @TODO support locking.
       $cache->locked = FALSE;
       return $cache;
+    }
     /**
      * Allow modules to provide their own caching mechanism for the display editor.
+     *
      * @param string $argument
      *   The second half of the cache key. Full key module:TASK_NAME:HANDLER_NAME
      *   passed part: TASK_NAME:HANDLER_NAME
      * @param stdClass $cache
      *   The display to cache.
+     *
      * @return stdClass
      *   The cached display.
      */
     function hook_panels_cache_save($argument, $cache) {
       list($handler, $item) = _panels_mini_panels_cache_get($argument);
       $item->display = $cache->display;
       panels_mini_save($item);
       $handler->edit_cache_clear($item);
       return $item;
+    }
     /**
      * Allow modules to provide their own caching mechanism for the display editor.
+     *
      * @param string $argument
      *   The second half of the cache key. Full key module:TASK_NAME:HANDLER_NAME
      *   passed part: TASK_NAME:HANDLER_NAME
      * @param stdClass $cache
      *   The cached display.
      */
     function hook_panels_cache_clear($argument, $cache) {
       list($handler, $item) = _panels_mini_panels_cache_get($argument);
       $handler->edit_cache_clear($item);
+    }
     /**
      * Allow modules to adjust the rendering array of the panels dashboard.
+     *
      * @param array $vars
      *   The output variables.
      */
     function hook_panels_dashboard_blocks(&$vars) {
       $vars['links']['panels_node'] = array(
         'title' => l(t('Panel node'), 'node/add/panel'),
         'description' => t('Panel nodes are node content and appear in your searches, but are more limited than panel pages.'),
         'weight' => -1,
       );
+    }
     /**
      * Allow to alter the pane content to render.
+     *
      * This happens after the keyword substitution.
+     *
      * @param stdClass $content
      *   The content block to render.
      * @param stdClass $pane
      *   The pane object.
      * @param array $args
      *   The display arguments.
      * @param array $contexts
      *   Array with the used contexts.
      */
     function hook_panels_pane_content_alter($content, $pane, $args, $contexts) {
       // Don't display titles.
       unset($content->title);
+    }
     /**
      * Allow modules to provide a mechanism to break locks.
+     *
      * @param string $argument
      *   The second half of the cache key. Full key module:TASK_NAME:HANDLER_NAME
      *   passed part: TASK_NAME:HANDLER_NAME
      * @param stdClass $cache
      *   The cached display.
      */
     function hook_panels_edit_cache_break_lock($argument, $cache) {
       $cache->locked = FALSE;
+    }
     /**
      * Fired before a panels display is rendered.
+     *
      * Last chance to modify the panels display or add output before the keyword
      * substitution runs and the panels display is rendered.
+     *
      * @param panels_display $panels_display
      *   The panels display that will be rendered.
      * @param stdClass $renderer
      *   The renderer object that will be used to render.
+     *
      * @return string
      *   Additional output to add before the panels display.
      */
     function hook_panels_pre_render($panels_display, $renderer) {
       $translation = i18n_string_object_translate('panels_display_configuration', $panels_display);
       $panels_display->title = $translation->title;
+    }
     /**
      * Fired after a panels display is rendered.
+     *
      * Allow to add additional output after the output of the panels display.
+     *
      * @param panels_display $panels_display
      *   The rendered panels display.
      * @param stdClass $renderer
      *   The used renderer object.
+     *
      * @return string
      *   Additional output to add after the panels display.
      */
     function hook_panels_post_render($panels_display, $renderer) {
       return t('Output proudly sponsored by panels.');
+    }
     /**
      * Fired before a new pane is inserted in the storage.
+     *
      * @param stdClass $pane
      *   Pane that will be rendered.
      */
     function hook_panels_pane_insert($pane) {
       // Check if this pane has a custom title enabled.
       if (!empty($pane->configuration['override_title'])) {
         $translation_object = (object) array(
           'pid' => $pane->pid,
           'title' => $pane->configuration['override_title_text'],
         );
         $status = i18n_string_object_update('panels_pane_configuration', $translation_object);
+      }
+    }
     /**
      * Fired before a changed pane is updated in the storage.
+     *
      * @param stdClass $pane
      *   Pane that will be rendered.
      */
     function hook_panels_pane_update($pane) {
       // Check if this pane has a custom title enabled.
       if (!empty($pane->configuration['override_title'])) {
         $translation_object = (object) array(
           'pid' => $pane->pid,
           'title' => $pane->configuration['override_title_text'],
         );
         $status = i18n_string_object_update('panels_pane_configuration', $translation_object);
+      }
+    }
     /**
      * Fired before a panel is rendered.
+     *
      * Last chance to modify the pane before the keyword substitution runs and the
      * pane is rendered.
+     *
      * @param stdClass $pane
      *   Pane that will be rendered.
      */
     function hook_panels_pane_prerender($pane) {
       // Check if this pane has a custom title enabled.
       if (!empty($pane->configuration['override_title'])) {
         $translation_object = (object) array(
           'pid' => $pane->pid,
           'title' => $pane->configuration['override_title_text'],
         );
         $translation_object = i18n_string_object_translate('panels_pane_configuration', $translation_object);
         $pane->configuration['override_title_text'] = $translation_object->title;
+      }
+    }
     /**
      * Fired before panes are deleted.
+     *
      * @param array $pids
      *   Array with the panel id's to delete.
      */
     function hook_panels_pane_delete($pids) {
       foreach ($pids as $pid) {
         // Create dummy pane with pid as property.
         $pane = (object) array('pid' => $pid);
         i18n_string_object_remove('panels_pane_configuration', $pane);
+      }
+    }
     /**
      * Fired after a display is saved.
+     *
      * @param panels_display $display
      *   The display to save.
      */
     function hook_panels_display_save($display) {
       i18n_string_object_update('display_configuration', $display);
+    }
     /**
      * Fired before a display is deleted.
+     *
      * @param integer $did
      *   Id of the display to delete.
      */
     function hook_panels_delete_display($did) {
       $uuid = db_select('panels_display')
         ->fields('panels_display', array('uuid'))
         ->condition('did', $did)
         ->execute()
         ->fetchColumn();
       $display = (object) array('uuid' => $uuid);
       i18n_string_object_remove('display_configuration', $display);
+    }

     core = 7.x
     package = "Panels"
     configure = admin/structure/panels
     dependencies[] = ctools
     dependencies[] = ctools (>=1.4)
     files[] = panels.module
     files[] = includes/common.inc
     files[] = includes/legacy.inc
     files[] = includes/plugins.inc
     files[] = plugins/views/panels_views_plugin_row_fields.inc
     ; Information added by drupal.org packaging script on 2012-08-18
     version = "7.x-3.3"
     ; Information added by Drupal.org packaging script on 2014-02-12
     version = "7.x-3.4"
     core = "7.x"
     project = "panels"
     datestamp = "1345319572"
     datestamp = "1392221614"

     function panels_schema() {
       // This should always point to our 'current' schema. This makes it relatively easy
       // to keep a record of schema as we make changes to it.
       return panels_schema_4();
       return panels_schema_5();
+    }
     function panels_schema_5() {
       $schema = panels_schema_4();
       $schema['panels_display']['fields']['uuid'] = array(
         'type' => 'char',
         'length' => '36',
       );
       $schema['panels_display']['export']['key'] = 'uuid';
       $schema['panels_display']['export']['key name'] = 'UUID';
       $schema['panels_pane']['fields']['uuid'] = array(
         'type' => 'char',
         'length' => '36',
       );
       $schema['panels_pane']['export']['key'] = 'uuid';
       $schema['panels_pane']['export']['key name'] = 'UUID';
       return $schema;
+    }
     function panels_schema_4() {
-...
         'primary key' => array('lid'),
       );
       $schema['cache_panels'] = drupal_get_schema_unprocessed('system', 'cache');
       return $schema;
+    }
-...
       return t('panels_pane.lock field already existed, update skipped.');
+    }
     /**
      * Adding universally unique identifiers to panels.
      */
     function panels_update_7302() {
       // Load the schema.
       $schema = panels_schema_5();
       $msg = array();
       // Add the uuid column to the pane table.
       $table = 'panels_pane';
       $field = 'uuid';
       // Due to a previous failure, the column may already exist:
       if (!db_field_exists($table, $field)) {
         $spec = $schema[$table]['fields'][$field];
         db_add_field($table, $field, $spec);
         $msg[] = t('Added panels_pane.uuid column.');
+      }
       // Add the uuid column to the display table.
       $table = 'panels_display';
       $field = 'uuid';
       // Due to a previous failure, the column may already exist:
       if (!db_field_exists($table, $field)) {
         $spec = $schema[$table]['fields'][$field];
         db_add_field($table, $field, $spec);
         $msg[] = t('Added panels_display.uuid column.');
+      }
       if (empty($msg)) {
         $msg[] = t('UUID column already present in the panels_display & panels_pane tables.');
+      }
       // Update all DB-based panes & displays to ensure that they all contain a UUID.
       $display_dids = db_select('panels_display')
         ->fields('panels_display', array('did'))
         ->condition(db_or()
           ->condition('uuid', '')
           ->isNull('uuid')
+        )
         ->execute()
         ->fetchCol();
       // Check the panes as well, for paranoia.
       $pane_dids = db_select('panels_pane')
         ->distinct()
         ->fields('panels_pane', array('did'))
         ->condition(db_or()
           ->condition('uuid', '')
           ->isNull('uuid')
+        )
         ->execute()
         ->fetchCol();
       $dids = array_unique(array_merge($display_dids, $pane_dids));
       if ($displays = panels_load_displays($dids)) {
         foreach ($displays as $display) {
           // A display save also triggers pane saves.
           panels_save_display($display);
+        }
         $msg[] = t('Generated UUIDs for database-based panel displays and panes.');
+      }
       else {
         $msg[] = t('No database-based panel displays or panes for which to generate UUIDs.');
+      }
       return implode("\n", $msg);
+    }
     /**
      * Add a custom cache table for Panels.
      */
     function panels_update_7303() {
       $table_name = 'cache_panels';
       if (!db_table_exists($table_name)) {
         $schema = drupal_get_schema_unprocessed('system', 'cache');
         db_create_table($table_name, $schema);
+      }
+    }

+      }
       ctools_add_css('panels', 'panels');
       ctools_add_js('panels', 'panels');
+    }
     /**
-...
           'title' => t('Use panel locks'),
           'description' => t('Allows a user to lock and unlock panes in a panel display.'),
         ),
         'use ipe with page manager' => array(
           'title' => t("Use the Panels In-Place Editor with Page Manager"),
           'description' => t('Allows users with access to the In-Place editor to administer page manager pages. This permission is only needed for users without "use page manager" access.'),
         ),
       );
+    }
-...
     //  $legacy->determineStatus();
     //}
     /**
      * Implements hook_flush_caches().
      */
     function panels_flush_caches() {
       return array('cache_panels');
+    }
     // ---------------------------------------------------------------------------
     // CTools hook implementations
     //
-...
           $pane->panel = $location;
+        }
         // Get a temporary pid for this pane.
         $pane->pid = "new-" . $this->next_new_pid();
         // Generate a permanent uuid for this pane, and use
         // it as a temporary pid.
         $pane->uuid = ctools_uuid_generate();
         $pane->pid = 'new-' . $pane->uuid;
         // Add the pane to the approprate spots.
         $this->content[$pane->pid] = &$pane;
-...
       function clone_pane($pid) {
         $pane = clone $this->content[$pid];
         $pane->uuid = ctools_uuid_generate();
         return $pane;
+      }
       function next_new_pid() {
         // We don't use static vars to record the next new pid because
         // temporary pids can last for years in exports and in caching
         // during editing.
         $id = array(0);
         foreach (array_keys($this->content) as $pid) {
           if (!is_numeric($pid)) {
             $id[] = substr($pid, 4);
+          }
+        }
         $next_id = max($id);
         return ++$next_id;
+      }
       /**
        * Get the title from a display.
+       *
-...
+     *
      * @ingroup mainapi
+     *
      * Note a new $display only receives a real did once it is run through this function.
      * Until then, it uses a string placeholder, 'new', in place of a real did. The same
      * applies to all new panes (whether on a new $display or not); in addition,
      * panes have sequential numbers appended, of the form 'new-1', 'new-2', etc.
      * Note that a new $display only receives a real did once it is run through
      * this function, and likewise for the pid of any new pane.
+     *
      * Until then, a new display uses a string placeholder, 'new', in place of
      * a real did, and a new pane (whether on a new $display or not) appends a
      * universally-unique identifier (which is stored permanently in the 'uuid'
      * field). This format is also used in place of the real pid for exports.
+     *
      * @param object $display instanceof panels_display \n
      *  The display object to be saved. Passed by reference so the caller need not use
-...
      */
     function panels_save_display(&$display) {
       $update = (isset($display->did) && is_numeric($display->did)) ? array('did') : array();
       if (empty($display->uuid) || !ctools_uuid_is_valid($display->uuid)) {
         $display->uuid = ctools_uuid_generate();
+      }
       drupal_write_record('panels_display', $display, $update);
       $pids = array();
-...
           $pane->did = $display->did;
           $old_pid = $pane->pid;
           if (empty($pane->uuid) || !ctools_uuid_is_valid($pane->uuid)) {
             $pane->uuid = ctools_uuid_generate();
+          }
           drupal_write_record('panels_pane', $pane, is_numeric($pid) ? array('pid') : array());
           // Allow other modules to take action after a pane is saved.
           if ($pane->pid == $old_pid) {
             module_invoke_all('panels_pane_update', $pane);
+          }
           else {
             module_invoke_all('panels_pane_insert', $pane);
+          }
           if ($pane->pid != $old_pid) {
             // and put it back so our pids and positions can be used
             unset($display->content[$id]);
             // Remove the old new-* entry from the displays content.
             unset($display->content[$pid]);
             // and put it back so our pids and positions can be used.
             $display->content[$pane->pid] = $pane;
             // If the title pane was one of our panes that just got its ID changed,
-...
         $display->panels[$id] = $new_panes;
+      }
       if (!empty($pids)) {
         // Allow other modules to take action before a panes are deleted.
         module_invoke_all('panels_pane_delete', $pids);
         db_delete('panels_pane')->condition('pid', $pids)->execute();
+      }
-...
       else {
         $did = $display;
+      }
       module_invoke_all('panels_delete_display', $did);
       db_delete('panels_display')->condition('did', $did)->execute();
       db_delete('panels_pane')->condition('did', $did)->execute();
+    }
-...
+     *
      * This function is primarily intended as a mechanism for cloning displays.
      * It generates an exact replica (in code) of the provided $display, with
      * the exception that it replaces all ids (dids and pids) with 'new-*' values.
      * Only once panels_save_display() is called on the code version of $display will
      * the exported display written to the database and permanently saved.
      * the exception that it replaces all ids (dids and pids) with place-holder
      * values (consisting of the display or pane's uuid, with a 'new-' prefix).
+     *
      * Only once panels_save_display() is called on the code version of $display
      * will the exported display be written to the database and permanently saved.
+     *
      * @see panels_page_export() or _panels_page_fetch_display() for sample implementations.
+     *
-...
      */
     function panels_export_display($display, $prefix = '') {
       ctools_include('export');
       if (empty($display->uuid) || !ctools_uuid_is_valid($display->uuid)) {
         $display->uuid = ctools_uuid_generate();
+      }
       $display->did = 'new-' . $display->uuid;
       $output = ctools_export_object('panels_display', $display, $prefix);
       $pid_counter = &drupal_static(__FUNCTION__, 0);
       // Initialize empty properties.
       $output .= $prefix . '$display->content = array()' . ";\n";
       $output .= $prefix . '$display->panels = array()' . ";\n";
-...
       if (!empty($display->content)) {
         $region_counters = array();
         foreach ($display->content as $pane) {
           $pid = 'new-' . ++$pid_counter;
           if (!isset($pane->uuid) || !ctools_uuid_is_valid($pane->uuid)) {
             $pane->uuid = ctools_uuid_generate();
+          }
           $pid = 'new-' . $pane->uuid;
           if ($pane->pid == $display->title_pane) {
             $title_pid = $pid;
+          }
-...
       if (!empty($display->context)) {
         if ($form_context = ctools_context_get_form($display->context)) {
           $form_context->form['#theme'] = 'panels_render_display_form';
           if (empty($form_context->form['#theme_wrappers']) || !in_array('form', $form_context->form['#theme_wrappers'])) {
             $form_context['#theme_wrappers'][] = 'form';
+          }
           $form_context->form['#display'] = &$display;
           return $form_context->form;
+        }
-...
      * then operate as a theme function of the form.
      */
     function theme_panels_render_display_form($vars) {
       // @todo this is probably broken in D7
       $render = $vars['element']['#display']->render();
       $vars['element']['#children'] = $render;
       return theme('form', $vars);
       return $vars['element']['#display']->render();
+    }
     // @layout
-...
+          }
           $element = contextual_pre_render_links($element);
           $links += $element['#links'];
           if(!empty($element['#links'])) {
             $links += $element['#links'];
+          }
+        }
         if ($links) {
-...
       // Add template file suggestion for content type and sub-type.
       $vars['theme_hook_suggestions'][] = $base . $delimiter . $content->type;
       $vars['theme_hook_suggestions'][] = $base . $delimiter . strtr($content->type, '-', '_') . $delimiter . strtr($content->subtype, '-', '_');
       $vars['theme_hook_suggestions'][] = $base . $delimiter . strtr(ctools_cleanstring($content->type, array('lower case' => TRUE)), '-', '_') . $delimiter . strtr(ctools_cleanstring($content->subtype, array('lower case' => TRUE)), '-', '_');
       $vars['pane_prefix'] = !empty($content->pane_prefix) ? $content->pane_prefix : '';
       $vars['pane_suffix'] = !empty($content->pane_suffix) ? $content->pane_suffix : '';
-...
      * Get display edit cache on behalf of panel context.
+     *
      * The key is the second half of the key in this form:
      * panel_context:TASK_NAME:HANDLER_NAME;
      * panel_context:TASK_NAME::HANDLER_NAME::args::url;
      */
     function panel_context_panels_cache_get($key) {
       ctools_include('common', 'panels');
-...
       // this loads the panel context inc even if we don't use the plugin.
       $plugin = page_manager_get_task_handler('panel_context');
       list($task_name, $handler_name) = explode(':', $key, 2);
       list($task_name, $handler_name, $args, $q) = explode('::', $key, 4);
       $page = page_manager_get_page_cache($task_name);
       if (isset($page->display_cache[$handler_name])) {
         return $page->display_cache[$handler_name];
-...
+      }
       $cache = new stdClass();
       $task = page_manager_get_task($page->task_id);
       //ctools_context_handler_get_all_contexts($page->task, $page->subtask, $handler);
       $arguments = array();
       if ($args) {
         $arguments = explode('\\', $args);
         $contexts = ctools_context_handler_get_task_contexts($task, $page->subtask, $arguments);
         $contexts = ctools_context_handler_get_handler_contexts($contexts, $handler);
+      }
       else {
         $contexts = ctools_context_handler_get_all_contexts($page->task, $page->subtask, $handler);
+      }

Projet

Général

Profil

Club Drupal

Révision 5a7e6170

Ajouté par Florent Torregrosa il y a environ 10 ans