Club Drupal

 * @file

// Hide title use to be TRUE/FALSE. So FALSE remains old behavior.

define('PANELS_TITLE_FIXED', 0);

// And TRUE meant no title.

define('PANELS_TITLE_NONE', 1);

// And this is the new behavior, where the title field will pick from a pane.

define('PANELS_TITLE_PANE', 2);

 * @return array

 *   An array with the major and minor versions

 * Implements hook_theme().

    'variables' => array(

      'title' => NULL,

      'id' => NULL,

      'image' => NULL,

      'link' => NULL,

      'class' => NULL,

    ),

    'variables' => array(

      'id' => NULL,

      'image' => NULL,

      'title' => NULL,

    ),

    'variables' => array(

      'content' => array(),

      'pane' => array(),

      'display' => array(),

    ),

    'variables' => array(

      'renderer' => NULL,

      'categories' => array(),

      'region' => NULL,

      'category' => NULL,

      'column_count' => 2,

    ),

    'variables' => array(

      'renderer' => NULL,

      'region' => NULL,

      'content_type' => NULL,

    ),

          'variables' => array(

            'css_id' => NULL,

            'content' => NULL,

            'settings' => NULL,

            'display' => NULL,

            'layout' => NULL,

            'renderer' => NULL,

          ),

        // If no theme function exists, assume template.

          // For preprocess.

          $theme[$data[$callback]]['file'] = $data['file'];

        'variables' => array(

          'content' => NULL,

          'pane' => NULL,

          'display' => NULL,

          'style' => NULL,

          'settings' => NULL,

        ),

        'variables' => array(

          'display' => NULL,

          'owner_id' => NULL,

          'panes' => NULL,

          'settings' => NULL,

          'region_id' => NULL,

          'style' => NULL,

        ),

      elseif (function_exists($data['hook theme'])) {

 * Implements hook_menu().

      elseif (function_exists($data['hook menu'])) {

 * Implements hook_init().

 * Implements hook_permission().

    // @todo

    'view pane admin links' => array(

      'description' => "",

    // @todo should we really have a global perm for this, or should it be moved into a pipeline question?

    'administer pane access' => array(

      'description' => "",

/**

 * CTools hook implementations.

 *

 * These aren't core Drupal hooks but they are just as important.

 */

 * Implements hook_ctools_plugin_directory().

  // To let the system know we implement task and task_handler plugins.

    // If we did we'd make a plugin/ctools_cache or something.

      // We can define layouts in themes.

      'load themes' => TRUE,

 * Implements hook_ctools_plugin_api().

  // Inform CTools about version information for various plugins implemented by

  // panels.

 * Implements hook_views_api().

 *

 * @see _ctools_process_data()

      'theme variables' => array(

        'settings' => NULL,

        'class' => NULL,

        'content' => NULL,

      ),

      'theme variables' => array(

        'settings' => NULL,

        'content' => NULL,

        'pane' => NULL,

        'display' => NULL,

      ),

/**

 * Generates Lorem Ipsum.

 *

 * @return string

 *   Lorem ipsum string.

 */

  return <<<LIPSUM

    <p>

      Lorem ipsum dolor sit amet, consectetur adipiscing elit. Phasellus at 

      velit dolor. Donec egestas tellus sit amet urna rhoncus adipiscing. Proin 

      nec porttitor sem. Maecenas aliquam, purus nec tempus dignissim, nulla arcu

      aliquam diam, non tincidunt massa ante vel dolor. Aliquam sapien sapien,

      tincidunt id tristique at, pretium sagittis libero.

    </p>

    <p>

      Nulla facilisi. Curabitur lacinia, tellus sed tristique consequat, diam

      lorem scelerisque felis, at dictum purus augue facilisis lorem. Duis

      pharetra dignissim rutrum. Curabitur ac elit id dui dapibus tincidunt.

      Nulla eget sem quam, non eleifend eros. Cras porttitor tempus lectus ac

      scelerisque. Curabitur vehicula bibendum lorem, vitae ornare ligula

      venenatis ut.

    </p>

LIPSUM;

  return theme(

    $plugin['theme'],

    array(

      'settings' => $settings,

      'class' => ctools_stylizer_get_css_class($plugin, $settings),

      'content' => panels_stylizer_lipsum(),

    )

  );

  $content = new stdClass();

    return theme(

      $plugin['theme'],

      array(

        'settings' => $settings,

        'content' => $content,

        'pane' => $pane,

        'display' => $display,

      )

    );

    return theme(

      'panels_pane',

      array(

        'content' => $content,

        'pane' => $pane,

        'display' => $display,

      )

    );

/**

 * Panels display editing.

 */

 * @defgroup mainapi Functions comprising the main panels API.

 * Sample implementations utiltizing the the complex $destination behavior can

 * be found in panels_page_edit_content() and, in a separate contrib module,

 * OG Blueprints (http://drupal.org/project/og_blueprints),

 * og_blueprints_blueprint_edit().

 * @param object $display

 *   Instanceof panels_display.

 *

 *   A fully loaded panels $display object, as returned from

 *   panels_load_display(). Merely passing a did is NOT sufficient.

 *   Note that 'fully loaded' means the $display must already be loaded with

 *   any contexts the caller wishes to have set for the display.

 * @param mixed $destination

 *   The redirect destination that the user should be taken to on form

 *   submission or cancellation. With panels_edit, $destination has complex

 *   effects on the return values of panels_edit() once the form has been

 *   submitted. See the explanation of the return value below to understand the

 *   different types of values returned by panels_edit() at different stages of

 *   FAPI. Under most circumstances, simply passing in drupal_get_destination()

 *   is all that's necessary.

 * @param array $content_types

 *   An associative array of allowed content types, typically as returned from

 *   panels_common_get_allowed_types(). Note that context partially governs

 *   available content types, so you will want to create any relevant contexts

 *   using panels_create_context() or panels_create_context_empty() to make sure

 *   all the appropriate content types are available.

 *

 * @return mixed

 *   Because the functions called by panels_edit() invoke the form API,

 *   this function returns different values depending on the stage of form

 *   submission we're at. In Drupal 5, the phase of form submission is indicated

 *   by the contents of $_POST['op']. Here is what you'll get at different

 *   stages:

 *     -  If !$_POST['op']: then we're on on the initial passthrough and the

 *        form is being rendered, so it's the $form itself that's being

 *        returned. Because negative margins, a common CSS technique, bork the

 *        display editor's ajax drag-and-drop, it's important that the $output

 *        be printed, not returned. Use this syntax in the caller function:

 *        print theme('page', panels_edit($display, $destination, $content_types), FALSE);

 *     -  If $_POST['op'] == t('Cancel'): form submission has been cancelled.

 *        If empty($destination) == FALSE, then there is no return value and the

 *        panels API takes care of redirecting to $destination.

 *        If empty($destination) == TRUE, then there's still no return value,

 *        but the caller function has to take care of form redirection.

 *     -  If $_POST['op'] == ('Save'): the form has been submitted successfully

 *        and has run through panels_edit_display_submit().

 *        $output depends on the value of $destination:

 *     -  If empty($destination) == TRUE: $output contains the modified $display

 *        object, and no redirection will occur. This option is useful if the

 *        caller needs to perform additional operations on or with the modified

 *        $display before the page request is complete. Using hook_form_alter()

 *        to add an additional submit handler is typically the preferred method

 *        for something like this, but there are certain use cases where that is

 *        infeasible and $destination = NULL should be used instead. If this

 *        method is employed, the caller will need to handle form redirection.

 *        Note that having $_REQUEST['destination'] set, whether via

 *        drupal_get_destination() or some other method, will NOT interfere with

 *        this functionality; consequently, you can use drupal_get_destination()

 *        to safely store your desired redirect in the caller function, then

 *        simply use drupal_goto() once panels_edit() has done its business.

 *     -  If empty($destination) == FALSE: the form will redirect to the URL

 *        string given in $destination and NO value will be returned.

 * @ingroup mainapi

 * Layout selection is nothing more than a list of radio items encompassing the

 * available layouts for this display, as defined by .inc files in the

 * panels/layouts subdirectory. The only real complexity occurs when a user

 * attempts to change the layout of a display that has some content in it.

 * @param object $display

 *   A fully loaded panels $display object, as returned from

 *   panels_load_display(). Merely passing a did is NOT sufficient.

 *   A string that will be used for the text of the form submission button. If

 *   no value is provided, then the form submission button will default to

 *   t('Save').

 *   Basic usage is a string containing the URL that the form should redirect to

 *   upon submission. For a discussion of advanced usages, see panels_edit().

 *   Allowed layouts has three different behaviors that depend on which of three

 *   value types are passed in by the caller:

 *     #- if $allowed_layouts instanceof panels_allowed_layouts

 *        (includes subclasses): the most complex use of the API. The caller is

 *        passing in a loaded panels_allowed_layouts object that the client

 *        module previously created and stored somewhere using a custom storage

 *        mechanism.

 *     #- if is_string($allowed_layouts): the string will be used in a call to

 *        variable_get() which will call the

 *        $allowed_layouts . '_allowed_layouts' var. If the data was stored

 *        properly in the system var, the $allowed_layouts object will be

 *        unserialized and recreated.

 *     #- if is_null($allowed_layouts): the default behavior, which also

 *        provides backwards compatibility for implementations of the Panels2

 *        API written before beta4. In this case, a dummy panels_allowed_layouts

 *        object is created which does not restrict any layouts. Subsequent

 *        behavior is indistinguishable from pre-beta4 behavior.

 *

 * @return mixed

 *   Can return nothing, or a modified $display object, or a redirection string;

 *   return values for the panels_edit* family of functions are quite complex.

 *   See panels_edit() for detailed discussion.

 *

 * @see panels_common_set_allowed_layouts()

/**

 * Panels database functions.

 */

 * Forms the basis of a panel display.

  public $args = array();

  public $content = array();

  public $panels = array();

  public $incoming_content = NULL;

  public $css_id = NULL;

  public $context = array();

  public $did = 'new';

  public $renderer = 'standard';

  /**

   * Add a pane.

   */

  public function add_pane(&$pane, $location = NULL) {

    // Add the pane to the appropriate spots.

  /**

   * Duplicate a pane.

   */

  public function duplicate_pane($pid, $location = FALSE) {

   * @return mixed

   *   The title to use. If NULL, this means to let any default title that may

   *   be in use pass through. i.e, do not actually set the title.

  public function get_title() {

      case FALSE;

        // For old exported panels that are not in the database.

   *

   * @return mixed

   *    NULL or output of render function.

  public function render($renderer = NULL) {

  public function access($op, $account = NULL) {

 * End of 'defgroup mainapi', although other functions are specifically added later.

 *   An indexed array of dids to be loaded from the database.

 * @return array

 *   An array of displays, keyed by their display dids.

  $result = db_query(

    "SELECT * FROM {panels_display} WHERE did IN (:dids)",

    array(':dids' => $dids)

  );

  $result = db_query(

    "SELECT * FROM {panels_pane} WHERE did IN (:dids) ORDER BY did, panel, position",

    array(':dids' => $dids)

  );

 *   The display id (did) of the display to be loaded.

 * @return object $display

 *   Returns a partially-loaded panels_display object. $display objects returned

 *   from this function have only the following data:

 *   While all of these members are defined, $display->context is NEVER defined in the returned $display;

 *   it must be set using one of the ctools_context_create() functions.

 * @ingroup mainapi

 * @param object $display

 *   The display object to be saved. Passed by reference so the caller need not

 *   use the return value for any reason except convenience.

 * @return object $display

 *   This display panel display object to return.

 *

 * @ingroup mainapi

    // Get a list of all panes currently in the database for this display so we

    // can know if there are panes that need to be deleted. (i.e, aren't

    // currently in our list of panes).

    $result = db_query(

      "SELECT pid FROM {panels_pane} WHERE did = :did",

      array(':did' => $display->did)

    );

  // Update all the panes.

        // Put it back so our pids and positions can be used.

              'title_pane' => $pane->pid,

  // Log the change to watchdog, using the same style as node.module.

  // To be nice, even though we have a reference.

 * @param object $display

 *   This export function does no loading of additional data about the provided

 *   display. Consequently, the caller should make sure that all the desired

 *   data has been loaded into the $display before calling this function.

 *   A string prefix that is prepended to each line of exported code. This is

 *   primarily used for prepending a double space when exporting so that the

 *   code indents and lines up nicely.

 *   The passed-in $display expressed as code, ready to be imported. Import by

 *   running eval($output) in the caller function; doing so will create a new

 *   $display variable with all the exported values. Note that if you have

 *   already defined a $display variable in the same scope as where you eval(),

 *   your existing $display variable WILL be overwritten.

 *

 * @see panels_page_export() or _panels_page_fetch_display() for samples.

 *

 * @ingroup mainapi

      $output .= $prefix . '$display->panels[\'' . $pane->panel . '\'][' . $region_counters[$pane->panel]++ . '] = \'' . $pane->pid . "';\n";

 * Panels Render Display.

 *

 *

        $form_context->form['#theme_wrappers'][] = 'form';

/**

 * Panels layout icon function.

 */

  return theme(

    'panels_layout_icon',

    array(

      'id' => $id,

      'image' => theme(

        'image',

        array(

          'path' => $file,

          'alt' => strip_tags($layout['title']),

          'title' => strip_tags($layout['description']),

        )

      ),

      'title' => $title,

    )

  );

 * Theme the layout icon image.

 *

 * Theme the layout link image.

 *

  $output = '<div class="' . implode(' ', $vars['class']) . '">';

 *

  // Setup classes for layout link, including current-layout information.

  $image = l(

    theme('image', array('path' => $file)),

    $link,

    array('html' => TRUE) + $options

  );

  return theme(

    'panels_layout_link',

    array(

      'title' => $title,

      'image' => $image,

      'class' => $class,

    )

  );

 * Panels Get legacy state.

 *

 *   Returns a legacy panels state.

      // Add content to $element array.

      if (!empty($element['#links'])) {

  // Basic classes.

  // Add some usable classes based on type/subtype.

  $type_class = $content->type ? 'pane-' . ctools_cleanstring($content->type, array('lower case' => TRUE)) : '';

  $subtype_class = $content->subtype ? 'pane-' . ctools_cleanstring($content->subtype, array('lower case' => TRUE)) : '';

  if (!empty($content->attributes)) {

    $vars['attributes_array'] = array_merge($vars['attributes_array'], $content->attributes);

  }

/**

 * Panels caching functions and callbacks.

 *

 * When editing displays and the like, Panels has a caching system that relies

 * on a callback to determine where to get the actual cache.

 *

 * @todo This system needs to be better documented so that it can be better used.

 */

  // We often store contexts in cache, so let's just make sure we can load them.

 * Panels Editor Cache Get.

 *

  // Fall back to our normal method.

 * Panels Editor Cache Set.

 *

  // Fall back to our normal method.

 * Panels Editor Cache Save.

 *

  // Fall back to our normal method.

 * Panels Editor Cache Clear.

 *

  // Fall back to our normal method.

/**

 * Callbacks on behalf of the panel_context plugin.

 *

 * The panel_context plugin lets Panels be used in page manager. These

 * callbacks allow the display editing system to use the page manager

 * cache rather than the default display cache. They are routed by the cache

 * key via panels_edit_cache_* functions.

 */

  // This loads the panel context inc even if we don't use the plugin.

/**

 * Callbacks on behalf of the panels page wizards.

 *

 * The page wizards are a pluggable set of 'wizards' to make it easy to create

 * specific types of pages based upon whatever someone felt like putting

 * together. Since they will very often have content editing, we provide

 * a generic mechanism to allow them to store their editing cache in the

 * wizard cache.

 *

 * For them to use this mechanism, they just need to use:

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

 */

 * Get display edit cache for the panels mini export UI.

/**

 * General utility functions.

 */

    // Prevent notices by adding defaults.

    return drupal_goto(

      $destination['path'],

      $destination['query'],

      $destination['fragment'],

      $destination['http_response_code']

    );

 * For external use: Given a layout ID and $content array, return panel display.

 * layout. If it's a two column with a content array defined like.

  // Get our simple renderer.

  // Add links to the Panels pane dropdown menu.

  if ($pane->type === "block") {

    // Breakup the subtype string into parts.

    // Get the first part of the string.

    // Get the first part of the string and add a hyphen.

    // Remove the prefix block- to get the name.

    $name_of_block = ltrim($prefixed_name, $subtype_prefix_hyphen);

    // Check for user added menus created at /admin/structure/menu/add

    // menus of that type have a subtype that is prefixed with menu-menu-.

    if (substr($prefixed_name, 0, 10) === "menu-menu-") {

      // Remove the first prefix menu- from menu-menu- to get the name.