PHPXRef 0.7 : Drupal 6 (yi-drupal) : Detail view of panels.module

Class: panels_display - X-Ref

Forms the basis of a panel display

panels_display() X-Ref

No description

add_pane(&$pane, $location = NULL) X-Ref

No description

duplicate_pane($pid, $location = FALSE) X-Ref

No description

clone_pane($pid) X-Ref

No description

next_new_pid() X-Ref

No description

get_title() X-Ref

Get the title from a display.

The display must have already been rendered, or the setting to set the
display's title from a pane's title will not have worked.

return:

render($renderer = NULL) X-Ref

Render this panels display.

After checking to ensure the designated layout plugin is valid, a
display renderer object is spawned and runs its rendering logic.

param: mixed $renderer

panels_new_display() X-Ref

Creates a new display, setting the ID to our magic new id.

panels_new_pane($type, $subtype, $set_defaults = FALSE) X-Ref

Create a new pane.

panels_load_displays($dids) X-Ref

Load and fill the requested $display object(s).

Helper function primarily for for panels_load_display().

param: array $dids
return: $displays

panels_load_display($did) X-Ref

Load a single display.

param: int $did
return: object $display instanceof panels_display \n

panels_save_display(&$display) X-Ref

Save a display object.

param: object $display instanceof panels_display \n
return: object $display instanceof panels_display \n

panels_delete_display($display) X-Ref

Delete a display.

panels_export_display($display, $prefix = '') X-Ref

Exports the provided display into portable code.

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.

param: object $display instanceof panels_display \n
param: string $prefix
return: string $output

panels_render_display(&$display, $renderer = NULL) X-Ref

Render a display by loading the content into an appropriate
array and then passing through to panels_render_layout.

if $incoming_content is NULL, default content will be applied. Use
an empty string to indicate no content.

theme_panels_render_display_form($form) X-Ref

Theme function to render our panel as a form.

When rendering a display as a form, the entire display needs to be
inside the <form> tag so that the form can be spread across the
panes. This sets up the form system to be the main caller and we
then operate as a theme function of the form.

panels_print_layout_icon($id, $layout, $title = NULL) X-Ref

No description

theme_panels_layout_icon($id, $image, $title = NULL) X-Ref

Theme the layout icon image

theme_panels_layout_link($title, $id, $image, $link) X-Ref

Theme the layout link image

panels_print_layout_link($id, $layout, $link, $options = array() X-Ref

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

panels_get_legacy_state() X-Ref

Gateway to the PanelsLegacyState class/object, which does all legacy state
checks and provides information about the cause of legacy states as needed.

return: PanelsLegacyState $legacy

panels_get_current_page_display($change = NULL) X-Ref

Get the display that is currently being rendered as a page.

Unlike in previous versions of this, this only returns the display,
not the page itself, because there are a number of different ways
to get to this point. It is hoped that the page data isn't needed
at this point. If it turns out there is, we will do something else to
get that functionality.

template_preprocess_panels_pane($vars) X-Ref

Clean up the panel pane variables for the template.

panels_ajax_router() X-Ref

Route Panels' AJAX calls to the correct object.

Panels' AJAX is controlled mostly by renderer objects. This menu callback
accepts the incoming request, figures out which object should handle the
request, and attempts to route it. If no object can be found, the default
Panels editor object is used.

Calls are routed via the ajax_* method space. For example, if visiting
panels/ajax/add-pane then $renderer::ajax_add_pane() will be called.
This means commands can be added without having to create new callbacks.

The first argument *must always* be the cache key so that a cache object
can be passed through. Other arguments will be passed through untouched
so that the method can do whatever it needs to do.

panels_cache_get($obj, $did, $skip_cache = FALSE) X-Ref

Get an object from cache.

panels_cache_set($obj, $did, $cache) X-Ref

Save the edited object into the cache.

panels_cache_clear($obj, $did) X-Ref

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

panels_edit_cache_get_default(&$display, $content_types = NULL, $title = FALSE) X-Ref

Create the default cache for editing panel displays.

If an application is using the Panels display editor without having
specified a cache key, this method can be used to create the default
cache.

panels_edit_cache_get($cache_key) X-Ref

Method to allow modules to provide their own caching mechanism for the
display editor.

panels_edit_cache_set($cache) X-Ref

Method to allow modules to provide their own caching mechanism for the
display editor.

panels_edit_cache_save($cache) X-Ref

Method to allow modules to provide their own mechanism to write the
cache used in the display editor.

panels_edit_cache_clear($cache) X-Ref

Method to allow modules to provide their own mechanism to clear the
cache used in the display editor.

panels_edit_cache_break_lock($cache) X-Ref

Method to allow modules to provide a mechanism to break locks.

panel_context_panels_cache_get($key) X-Ref

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_panels_cache_get_page_cache($key, $cache) X-Ref

Get the Page Manager cache for the panel_context plugin.

panel_context_panels_cache_set($key, $cache) X-Ref

Store a display edit in progress in the page cache.

panel_context_panels_cache_clear($key, $cache) X-Ref

Save all changes made to a display using the Page Manager page cache.

panel_context_panels_cache_save($key, $cache) X-Ref

Save all changes made to a display using the Page Manager page cache.

panel_context_panels_cache_break_lock($key, $cache) X-Ref

Break the lock on a page manager page.

panels_page_wizard_panels_cache_get($key) X-Ref

Get display edit cache for the panels mini export UI

The key is the second half of the key in this form:
panels_page_wizard:TASK_NAME:HANDLER_NAME;

panels_page_wizard_panels_cache_set($key, $cache) X-Ref

Store a display edit in progress in the page cache.

panels_goto($destination) X-Ref

Perform a drupal_goto on a destination that may be an array like url().

panels_print_layout($layout, $content, $meta = 'standard') X-Ref

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

The content array is filled in based upon the content available in the
layout. If it's a two column with a content array defined like

panels_load_include($include, $path = 'includes/') X-Ref

Load a panels include file.

panels_get_path($file, $base_path = FALSE, $module = 'panels') X-Ref

panels path helper function

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

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

panels_get_panels($layout, $display) X-Ref

Get a list of panel regions available in the layout.

panels_pane_select_context($pane, $contexts) X-Ref

Select a context for a pane.

param: $pane
param: $contexts
return:

Functions

Functions that are not part of a class:

panels_api_version() X-Ref

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

return: An array with the major and minor versions

panels_theme() X-Ref

Implementation of hook_theme()

panels_menu() X-Ref

Implementation of hook_menu

panels_edit_cache_load($cache_key) X-Ref

Menu loader function to load a cache item for Panels AJAX.

This load all of the includes needed to perform AJAX, and loads the
cache object and makes sure it is valid.

panels_init() X-Ref

Implementation of hook_init()

panels_perm() X-Ref

Implementation of hook_perm

panels_flush_caches() X-Ref

Implementation of hook_flush_caches().

We implement this so that we can be sure our legacy rendering state setting
in $conf is updated whenever caches are cleared.

panels_ctools_plugin_directory($module, $plugin) X-Ref

Implementation of hook_ctools_plugin_directory() to let the system know
we implement task and task_handler plugins.

panels_ctools_plugin_layouts() X-Ref

Inform CTools that the layout plugin can be loaded from themes.

panels_layout_process(&$plugin) X-Ref

Ensure a layout has a minimal set of data.

panels_ctools_plugin_styles() X-Ref

Inform CTools that the style plugin can be loaded from themes.

panels_ctools_plugin_api($owner, $api) X-Ref

Implementation of hook_ctools_plugin_api().

Inform CTools about version information for various plugins implemented by
Panels.

param: string $owner
param: string $api

panels_views_api() X-Ref

Implementation of hook_views_api().

panels_plugin_styles_process(&$plugin, $info) X-Ref

Perform additional processing on a style plugin.

Currently this is only being used to apply versioning information to style
plugins in order to ensure the legacy renderer passes the right type of
parameters to a style plugin in a hybrid environment of both new and old
plugins.

param: array $plugin
param: array $info

panels_ctools_style_base_types() X-Ref

Declare what style types Panels uses.

panels_stylizer_lipsum() X-Ref

No description

panels_stylizer_region_preview($plugin, $settings) X-Ref

Generate a preview given the current settings.

panels_stylizer_pane_preview($plugin, $settings) X-Ref

Generate a preview given the current settings.

panels_edit($display, $destination = NULL, $content_types = NULL, $title = FALSE) X-Ref

Main API entry point to edit a panel display.

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 \n
param: mixed $destination \n
param: array $content_types \n
return:

panels_edit_layout($display, $finish, $destination = NULL, $allowed_layouts = NULL) X-Ref

API entry point for selecting a layout for a given display.

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 instanceof panels_display \n
param: string $finish
param: mixed $destination
param: mixed $allowed_layouts
return:

File Size:	1685 lines (58 kb)
Included or required:	0 times
Referenced:	0 times
Includes or requires:	0 files

PHP Cross Reference of Drupal 6 (yi-drupal)

/sites/all/modules/panels/ -> panels.module (summary)

Defines 1 class

Defines 48 functions