' . $links . '
';
+ return $handlebar . $output;
+}
+
+function theme_panels_ipe_region_wrapper($output, $region_id, $display) {
+ return $output;
+}
+
+function theme_panels_ipe_add_pane_button($region_id, $display) {
+ $attr = array('class' => 'ctools-use-modal');
+ $link = l(t('add new pane'), "panels_ipe/ajax/add-pane/$display->cache_key/$region_id", array('attributes' => $attr));
+ return '' . $link . '
';
+}
+
+function panels_ipe_ajax_render_pane($pid, $cache) {
+ $class = ctools_plugin_load_class('panels', 'display_renderers', 'panels_renderer_single_pane', 'handler');
+ $renderer = new $class();
+ $renderer->build($cache->display, $pid);
+ $output = array();
+ $output[] = ctools_ajax_command_replace("#panels-ipe-paneid-$pid > .panels-ipe-proper-pane", $renderer->render());
+
+ ctools_ajax_render($output);
+}
+
+function panels_ipe_get_cache_key($key = NULL) {
+ static $cache;
+ if (isset($key)) {
+ $cache = $key;
+ }
+ return $cache;
+}
+
+/**
+ * AJAX entry point to create the controller form for an IPE.
+ *
+ * TODO this can be moved into the IPE plugin probably
+ */
+function panels_ipe_ajax_edit($cache) {
+ $display = $cache->display;
+ ctools_include('form');
+
+ $form_state = array(
+ 'display' => &$display,
+ 'content_types' => $cache->content_types,
+ 'rerender' => FALSE,
+ 'no_redirect' => TRUE,
+ );
+
+ $output = ctools_build_form('panels_ipe_edit_control_form', $form_state);
+ // no output == submit
+ if (!$output) {
+ if (!empty($form_state['clicked_button']['#save-display'])) {
+ panels_save_display($display);
+ }
+ // panels_cache_clear('display', $display->did);
+ drupal_json(1);
+ }
+ else {
+ drupal_json($output);
+ }
+ exit;
+}
+
+function panels_ipe_edit_control_form(&$form_state) {
+ $display = &$form_state['display'];
+ $display->cache_key = isset($display->cache_key) ? $display->cache_key : $display->did;
+
+ // Annoyingly, theme doesn't have access to form_state so we have to do this.
+ $form['#display'] = $display;
+
+ $layout = panels_get_layout($display->layout);
+ $layout_panels = panels_get_panels($layout, $display);
+
+ $form['panel'] = array('#tree' => TRUE);
+ $form['panel']['pane'] = array('#tree' => TRUE);
+
+ foreach ($layout_panels as $panel_id => $title) {
+ // Make sure we at least have an empty array for all possible locations.
+ if (!isset($display->panels[$panel_id])) {
+ $display->panels[$panel_id] = array();
+ }
+
+ $form['panel']['pane'][$panel_id] = array(
+ // Use 'hidden' instead of 'value' so the js can access it.
+ '#type' => 'hidden',
+ '#default_value' => implode(',', (array) $display->panels[$panel_id]),
+ );
+ }
+
+ $form['buttons']['submit'] = array(
+ '#type' => 'submit',
+ '#value' => t('Save'),
+ '#id' => 'panels-ipe-save',
+ '#submit' => array('panels_edit_display_form_submit'),
+ '#save-display' => TRUE,
+ );
+ $form['buttons']['cancel'] = array(
+ '#type' => 'submit',
+ '#value' => t('Cancel'),
+ );
+ return $form;
+}
+
+/**
+ * Experimenting with this as a means for outputting the display editor form.
+ * @param unknown_type $main
+ */
+function panels_ipe_footer($main = 0) {
+ $key = panels_ipe_get_cache_key();
+ if (!isset($key)) {
+ return;
+ }
+ // TODO should be moved into the IPE plugin - WAAAY too hardcoded right now
+ $output = "";
+ $output .= "
";
+ $output .= "
";
+ $output .= "" . t('Customize this page') . "";
+ $output .= "
";
+ $output .= "
";
+ $output .= "
";
+ return $output;
+}
+
+/**
+ * COPIED STRAIGHT OUT OF DISPLAY-EDIT.INC.
+ *
+ * This duplication will go away...once I figure out how to refactor out the
+ * hard-codedness of much of display-edit.inc.
+ */
+
+
+/**
+ * Entry point for AJAX: 'Add Content' modal form, from which the user selects the
+ * type of pane to add.
+ *
+ * @param int $cache
+ * The display id of the $display object currently being edited.
+ * @param string $panel_id
+ * A string with the name of the panel region to which the selected
+ * pane type will be added.
+ */
+function panels_ipe_ajax_add_pane_choose($cache, $panel_id = NULL, $category = NULL) {
+ $display = $cache->display;
+ $layout = panels_get_layout($display->layout);
+ $layout_panels = panels_get_panels($layout, $display);
+
+ if ($layout && array_key_exists($panel_id, $layout_panels)) {
+ ctools_modal_render(
+ t('Add content to !s', array('!s' => $layout_panels[$panel_id])),
+ panels_ipe_add_content($cache, $panel_id, $category)
+ );
+ }
+
+ ctools_modal_render(t('Error'), t('Invalid input'));
+}
+
+/**
+ * Display a list of content available.
+ */
+function panels_ipe_add_content($cache, $panel_id, $key) {
+ ctools_include('content');
+ $cache_key = $cache->display->cache_key;
+
+ $category_names = array();
+ $categories = array();
+ $titles = array();
+
+ foreach ($cache->content_types as $type_name => $subtypes) {
+ if (is_array($subtypes)) {
+ $content_type = ctools_get_content_type($type_name);
+ foreach ($subtypes as $subtype_name => $subtype_info) {
+ $title = filter_xss_admin($subtype_info['title']);
+ $description = isset($subtype_info['description']) ? $subtype_info['description'] : $title;
+
+ $icon = ctools_content_admin_icon($subtype_info);
+
+ if (isset($subtype_info['top level'])) {
+ $category = 'root';
+ }
+ else if (isset($subtype_info['category'])) {
+ if (is_array($subtype_info['category'])) {
+ list($category, $weight) = $subtype_info['category'];
+ }
+ else {
+ $category = $subtype_info['category'];
+ }
+ }
+ else {
+ $category = t('Uncategorized');
+ }
+
+ $category_key = preg_replace('/[^a-z0-9]/', '-', strtolower($category));
+
+ $output = '
';
+ $url = "panels_ipe/ajax/add-pane-config/$cache_key/$panel_id/$type_name/$subtype_name";
+ $output .= ctools_ajax_image_button($icon, $url, $description, 'panels-modal-add-config');
+ $output .= '
' . ctools_ajax_text_button($title, $url, $description, 'panels-modal-add-config') . '
';
+ $output .= '
';
+ if (!isset($categories[$category_key])) {
+ $category_names[$category_key] = $category;
+ $categories[$category_key] = array();
+ $titles[$category_key] = array();
+ }
+
+ $categories[$category_key][] = $output;
+ $titles[$category_key][] = $title;
+ }
+ }
+ }
+ if (!$categories) {
+ $output = t('There are no content types you may add to this display.');
+ }
+ else {
+ if (!empty($category_names['root'])) {
+ unset($category_names['root']);
+ }
+
+ $output = '
';
+ natcasesort($category_names);
+ $selector = '
';
+
+ // Render our list of categories in column 0.
+ foreach ($category_names as $category => $name) {
+ $class = 'panels-modal-add-category';
+ if ($category == $key) {
+ $class .= ' active';
+ }
+
+ $url = "panels_ipe/ajax/add-pane/$cache_key/$panel_id/$category";
+ $selector .= ctools_ajax_text_button($name, $url, '', $class);
+ }
+
+ $selector .= '
';
+ if (!empty($categories['root'])) {
+ foreach ($titles['root'] as $id => $title) {
+ $selector .= $categories['root'][$id];
+ }
+ }
+
+ if (empty($key) || empty($category_names[$key]) || $key == 'root') {
+// $key = current(array_keys($category_names));
+ $center = '
';
+ $center .= t('Content options are divided by category. Please select a category from the left to proceed.');
+ $center .= '
';
+ }
+ else {
+ natcasesort($titles[$key]);
+
+ // Fill out the info for our current category.
+ $columns = 2;
+ $col[1] = '';
+ $col[2] = '';
+
+ $col_size = count($titles[$key]) / $columns;
+ $count = 0;
+ foreach ($titles[$key] as $id => $title) {
+ $which = floor($count++ / $col_size) + 1; // we leave 0 for the categories.
+ $col[$which] .= $categories[$key][$id];
+ }
+
+ $center = '';
+ foreach ($col as $id => $column) {
+ $center .= '
';
+ }
+ $center .= '
'; // columns
+ }
+ $output .= '
';
+ $output .= '
';
+ $output .= $center;
+ $output .= '
'; // categories box
+ }
+ return $output;
+}
+
+/**
+ * AJAX entry point for to configure a pane that has just been added.
+ */
+function panels_ipe_ajax_add_pane_config($cache, $panel_id = NULL, $type_name = NULL, $subtype_name = NULL, $step = NULL) {
+ ctools_include('content');
+ $cache_key = $cache->display->cache_key;
+ $content_type = ctools_get_content_type($type_name);
+ $subtype = ctools_content_get_subtype($content_type, $subtype_name);
+
+ if (!isset($step) || !isset($cache->new_pane)) {
+ $pane = panels_new_pane($type_name, $subtype_name);
+ $pane->configuration = ctools_content_get_defaults($content_type, $subtype);
+ $pane->panel = $panel_id;
+ $cache->new_pane = &$pane;
+ }
+ else {
+ $pane = $cache->new_pane;
+ }
+
+ $form_state = array(
+ 'display' => &$cache->display,
+ 'contexts' => $cache->display->context,
+ 'pane' => &$pane,
+ 'cache_key' => $cache_key,
+ 'cache' => &$cache,
+ 'ajax' => TRUE,
+ 'modal' => TRUE,
+ 'commands' => array(),
+ );
+
+ $form_info = array(
+ 'path' => "panels_ipe/ajax/add-pane-config/$cache_key/$panel_id/$type_name/$subtype_name/%step",
+ 'next callback' => 'panels_ipe_ajax_edit_pane_config_next',
+ 'finish callback' => 'panels_ipe_ajax_add_pane_config_finish',
+ );
+
+ $rc = ctools_content_form('add', $form_info, $form_state, $content_type, $pane->subtype, $subtype, $pane->configuration, $step);
+ if ($rc === FALSE) {
+ panels_ipe_ajax_add_pane_config_finish($form_state);
+ $form_state['commands'][] = ctools_modal_command_dismiss();
+ ctools_ajax_render($form_state['commands']);
+ }
+}
+
+/**
+ * AJAX entry point for to configure a pane that has just been added.
+ */
+function panels_ipe_ajax_configure_pane($cache, $pid = NULL, $step = NULL) {
+ ctools_include('content');
+ $cache_key = $cache->display->cache_key;
+ if (empty($cache->display->content[$pid])) {
+ ctools_modal_render(t('Error'), t('Invalid pane id.'));
+ }
+
+ $pane = &$cache->display->content[$pid];
+
+ $content_type = ctools_get_content_type($pane->type);
+ $subtype = ctools_content_get_subtype($content_type, $pane->subtype);
+
+ $form_state = array(
+ 'display' => &$cache->display,
+ 'contexts' => $cache->display->context,
+ 'pane' => &$pane,
+ 'cache' => &$cache,
+ 'ajax' => TRUE,
+ 'modal' => TRUE,
+ 'commands' => array(),
+ );
+
+ $form_info = array(
+ 'path' => "panels_ipe/ajax/configure/$cache_key/$pid/%step",
+ 'next callback' => 'panels_ipe_ajax_edit_pane_config_next',
+ 'finish callback' => 'panels_ipe_ajax_edit_pane_config_finish',
+ );
+
+ ctools_content_form('edit', $form_info, $form_state, $content_type, $pane->subtype, $subtype, $pane->configuration, $step);
+}
+
+function panels_ipe_ajax_edit_pane_config_next(&$form_state) {
+ $form_state['cache']->new_pane = $form_state['pane'];
+ panels_edit_cache_set($form_state['cache']);
+}
+
+function panels_ipe_ajax_add_pane_config_finish(&$form_state) {
+ $cache = &$form_state['cache'];
+ $pane = $cache->new_pane;
+ unset($cache->new_pane);
+
+ // Get a real pid for this pane.
+ $pane->pid = "new-" . $cache->display->next_new_pid();
+ // Put the pane into the display where it belongs
+
+ $cache->display->content[$pane->pid] = $pane;
+ $cache->display->panels[$pane->panel][] = $pane->pid;
+
+ $class = ctools_plugin_load_class('panels', 'display_renderers', 'panels_renderer_ipe', 'handler');
+ $renderer = new $class();
+ $renderer->build($cache->display);
+ panels_edit_cache_set($cache);
+
+ $form_state['commands'][] = ctools_ajax_command_append("#panels-ipe-regionid-$pane->panel", $renderer->render_pane($pane));
+}
+
+function panels_ipe_ajax_edit_pane_config_finish(&$form_state) {
+ $cache = &$form_state['cache'];
+ $pane = &$form_state['pane'];
+
+ $class = ctools_plugin_load_class('panels', 'display_renderers', 'panels_renderer_single_pane', 'handler');
+ $renderer = new $class();
+ $renderer->build($cache->display);
+ $renderer->prepare($pane->pid);
+ panels_edit_cache_set($cache);
+
+ $form_state['commands'][] = ctools_ajax_command_replace("#panels-ipe-paneid-$pane->pid > .panels-ipe-portlet-content *", $renderer->render());
+}
diff --git panels_ipe/plugins/display_renderers/panels_renderer_ipe.class.php panels_ipe/plugins/display_renderers/panels_renderer_ipe.class.php
new file mode 100644
index 0000000..d601b55
--- /dev/null
+++ panels_ipe/plugins/display_renderers/panels_renderer_ipe.class.php
@@ -0,0 +1,84 @@
+display->cache_key}' class='panels-ipe-display-container'>$output
" . $output . "
";
+ }
+
+ /**
+ * Add an 'empty' pane placeholder above all the normal panes, and
+ * @param $region_id
+ * @param $panes
+ */
+ function render_region($region_id, $panes) {
+ // Generate this region's 'empty' placeholder pane from the IPE plugin.
+ $empty_ph = theme('panels_ipe_placeholder_pane', $region_id, $this->plugins['layout']['panels'][$region_id]);
+ // Wrap the placeholder in some guaranteed markup.
+ $panes['empty_placeholder'] = '' . $empty_ph . "
";
+ // Generate this region's add new pane button. FIXME waaaaay too hardcoded
+ $panes['add_button'] = theme('panels_ipe_add_pane_button', $region_id, $this->display);
+
+ $output = parent::render_region($region_id, $panes);
+ $output = theme('panels_ipe_region_wrapper', $output, $region_id, $this->display);
+ $classes = 'panels-ipe-region';
+ // Use the canonical list of empty regions to determine whether or not this
+ // region should initially be marked empty. It is important that we use the
+ // list instead of introspecting on render data so that this behavior is
+ // easily controlled externally.
+ if (array_search($region_id, $this->prepared['empty regions'])) {
+ $classes .= ' panels-ipe-region-empty';
+ }
+ return "" . $output . "
";
+ }
+}
diff --git panels_ipe/plugins/display_renderers/panels_renderer_ipe.inc panels_ipe/plugins/display_renderers/panels_renderer_ipe.inc
new file mode 100644
index 0000000..9b8b693
--- /dev/null
+++ panels_ipe/plugins/display_renderers/panels_renderer_ipe.inc
@@ -0,0 +1,8 @@
+ array(
+ 'class' => 'panels_renderer_ipe',
+ 'parent' => 'panels_renderer_default',
+ ),
+);
\ No newline at end of file
diff --git panels_mini/panels_mini.module panels_mini/panels_mini.module
index d96ef26..81b93b1 100644
--- panels_mini/panels_mini.module
+++ panels_mini/panels_mini.module
@@ -77,7 +77,7 @@ function panels_mini_block($op = 'list', $delta = 0, $edit = array()) {
$block = array();
$block['content'] = panels_render_display($panel_mini->display);
- $block['subject'] = panels_display_get_title($panel_mini->display);
+ $block['subject'] = $panel_mini->display->get_title();
// If NULL, fall back to this title:
if (!isset($block['subject'])) {
$block['subject'] = $panel_mini->title;
diff --git panels_stylizer/panels_stylizer.module panels_stylizer/panels_stylizer.module
index b3d92f6..f89f7be 100644
--- panels_stylizer/panels_stylizer.module
+++ panels_stylizer/panels_stylizer.module
@@ -135,6 +135,23 @@ function panels_stylizer_perm() {
}
/**
+ * Implementation of hook_ctools_plugin_api().
+ *
+ * Inform CTools that panels_stylizer's style plugins are up-to-date.
+ *
+ * @param string $owner
+ * The system name of the module owning the API about which information is
+ * being requested.
+ * @param string $api
+ * The name of the API about which information is being requested.
+ */
+function panels_stylizer_ctools_plugin_api($owner, $api) {
+ if ($owner == 'panels' && $api = 'styles') {
+ return array('version' => 2.0);
+ }
+}
+
+/**
* Implementation of hook_theme()
*/
function panels_stylizer_theme() {
diff --git panels_stylizer/plugins/styles/stylizer.inc panels_stylizer/plugins/styles/stylizer.inc
index 6029f4c..786d593 100644
--- panels_stylizer/plugins/styles/stylizer.inc
+++ panels_stylizer/plugins/styles/stylizer.inc
@@ -14,7 +14,7 @@ $plugin = array(
'render pane' => 'panels_stylizer_stylizer_style_render_pane',
'pane settings form' => 'panels_stylizer_stylizer_style_pane_settings_form',
- 'render panel' => 'panels_stylizer_stylizer_style_render_region',
+ 'render region' => 'panels_stylizer_stylizer_style_render_region',
'settings form' => 'panels_stylizer_stylizer_style_region_settings_form',
// 'settings validate' => 'panels_stylizer_stylizer_style_settings_validate',
@@ -26,8 +26,8 @@ $plugin = array(
function theme_panels_stylizer_stylizer_style_render_region($display, $panel_id, $panes, $style_settings) {
$output = '';
- foreach ($panes as $pane_id => $content) {
- $output .= panels_render_pane($content, $display->content[$pane_id], $display);
+ foreach ($panes as $pane_id => $pane_output) {
+ $output .= $pane_output;
}
if ($style_settings['style'] == '$') {
diff --git plugins/display_renderers/panels_renderer_default.class.php plugins/display_renderers/panels_renderer_default.class.php
new file mode 100644
index 0000000..c67b661
--- /dev/null
+++ plugins/display_renderers/panels_renderer_default.class.php
@@ -0,0 +1,462 @@
+build($display);
+ * $html_output = $renderer->render();
+ * @endcode
+ *
+ * Internally, the render pipeline is divided into two phases, prepare and
+ * render:
+ * - The prepare phase transforms the skeletal data on the provided
+ * display object into a structure that is expected by the render phase.
+ * It is divided into a series of discrete sub-methods and operates
+ * primarily by passing parameters, all with the intention of making
+ * subclassing easier.
+ * - The render phase relies primarily on data stored in the renderer object's
+ * properties, presumably set in the prepare phase. It iterates through the
+ * rendering of each pane, pane styling, placement in panel regions, region
+ * styling, and finally the arrangement of rendered regions in the layout.
+ * Caching, if in use, is triggered per pane, or on the entire display.
+ *
+ * In short: prepare builds conf, render renders conf. Subclasses should respect
+ * this separation of responsibilities by adhering to these loose guidelines,
+ * given a loaded display object:
+ * - If your renderer needs to modify the datastructure representing what is
+ * to be rendered (panes and their conf, styles, caching, etc.), it should
+ * use the prepare phase.
+ * - If your renderer needs to modify the manner in which that renderable
+ * datastructure data is rendered, it should use the render phase.
+ *
+ * In the vast majority of use cases, this default renderer will be sufficient
+ * and need not be switched out/subclassed; style plugins and/or layout plugins
+ * accomplish everything needed. If you think you might need a custom
+ * renderer, consider the following criteria/examples:
+ * - Some additional markup needs to be added to EVERY SINGLE panel.
+ * - Given a full display object, just render one pane.
+ * - Show a Panels admin interface.
+ *
+ * The system is almost functionally identical to the old procedural approach,
+ * with some exceptions (@see panels_renderer_legacy for details). The approach
+ * here differs primarily in its friendliness to tweaking via inheritance.
+ */
+class panels_renderer_default {
+ /**
+ * The Panels display object that is to be rendered.
+ *
+ * @var panels_display
+ */
+ var $display;
+
+ /**
+ * An associative array of loaded plugins. Used primarily as a central
+ * location for storing plugins that require additional loading beyond
+ * reading the plugin definition, which is already statically cached by
+ * ctools_get_plugins(). An example is layout plugins, which can optionally
+ * have a callback that determines the set of panel regions available at
+ * runtime.
+ *
+ * @var array
+ */
+ var $plugins = array();
+
+ /**
+ * A multilevel array of rendered data. The first level of the array
+ * indicates the type of rendered data, typically with up to three keys:
+ * 'layout', 'regions', and 'panes'. The relevant rendered data is stored as
+ * the value for each of these keys as it is generated:
+ * - 'panes' are an associative array of rendered output, keyed on pane id.
+ * - 'regions' are an associative array of rendered output, keyed on region
+ * name.
+ * - 'layout' is the whole of the rendered output.
+ *
+ * @var array
+ */
+ var $rendered = array();
+
+ /**
+ * A multilevel array of data prepared for rendering. The first level of the
+ * array indicates the type of prepared data. The standard renderer populates
+ * and uses two top-level keys, 'panes' and 'regions':
+ * - 'panes' are an associative array of pane objects to be rendered, keyed
+ * on pane id and sorted into proper rendering order.
+ * - 'regions' are an associative array of regions, keyed on region name,
+ * each of which is itself an indexed array of pane ids in the order in
+ * which those panes appear in that region.
+ *
+ * @var array
+ */
+ var $prepared = array();
+
+ /**
+ * Boolean state variable, indicating whether or not the prepare() method has
+ * been run.
+ *
+ * This state is checked in panels_renderer_default::render_layout() to
+ * determine whether the prepare method should be automatically triggered.
+ * @var bool
+ */
+ var $prep_run = FALSE;
+
+ /**
+ * Receive and store the display object to be rendered.
+ *
+ * This is a psuedo-constructor that should typically be called immediately
+ * after object construction.
+ *
+ * @param panels_display $display
+ * The panels display object to be rendered.
+ */
+ function build(&$display) {
+ $layout = panels_get_layout($display->layout);
+ $this->display = &$display;
+ $this->plugins['layout'] = $layout;
+ if (!isset($layout['panels'])) {
+ $this->plugins['layout']['panels'] = panels_get_panels($layout, $display);
+ }
+ }
+
+ /**
+ * Prepare the attached display for rendering.
+ *
+ * This is the outermost prepare method. It calls several sub-methods as part
+ * of the overall preparation process. This compartmentalization is intended
+ * to ease the task of modifying renderer behavior in child classes.
+ *
+ * If you override this method, it is important that you either call this
+ * method via parent::prepare(), or manually set $this->prep_run = TRUE.
+ *
+ * @param mixed $external_settings
+ * An optional parameter allowing external code to pass in additional
+ * settings for use in the preparation process. Not used in the default
+ * renderer, but included for interface consistency.
+ */
+ function prepare($external_settings = NULL) {
+ $this->prepare_panes($this->display->content);
+ $this->prepare_regions($this->display->panels, $this->display->panel_settings);
+ $this->prepared['empty regions'] = array_diff(array_keys($this->plugins['layout']['panels']), array_keys($this->prepared['regions']));
+ $this->prep_run = TRUE;
+ }
+
+ /**
+ * Prepare the list of panes to be rendered, accounting for visibility/access
+ * settings and rendering order.
+ *
+ * This method represents the standard approach for determining the list of
+ * panes to be rendered that is compatible with all parts of the Panels
+ * architecture. It first applies visibility & access checks, then sorts panes
+ * into their proper rendering order, and returns the result as an array.
+ *
+ * Inheriting classes should override this method if that renderer needs to
+ * regularly make additions to the set of panes that will be rendered.
+ *
+ * @param array $panes
+ * An associative array of panes, keyed on pane id.
+ * @return array
+ * An associative array of panes to be rendered, keyed on pane id and sorted
+ * into proper rendering order.
+ */
+ function prepare_panes($panes) {
+ ctools_include('content');
+ // Use local variables as writing to them is very slightly faster
+ $normal = $last = array();
+
+ // Prepare the list of panes to be rendered
+ foreach ($panes as $pid => $pane) {
+ // TODO remove in 7.x and ensure the upgrade path weeds out any stragglers; it's been long enough
+ $pane->shown = !empty($pane->shown); // guarantee this field exists.
+ // If this pane is not visible to the user, skip out and do the next one
+ if (!$pane->shown || !panels_pane_access($pane, $this->display)) {
+ continue;
+ }
+
+ $ct_plugin_def = ctools_get_content_type($pane->type);
+
+ // If this pane wants to render last, add it to the $last array. We allow
+ // this because some panes need to be rendered after other panes,
+ // primarily so they can do things like the leftovers of forms.
+ if (!empty($ct_plugin_def['render last'])) {
+ $last[$pid] = $pane;
+ }
+ // Otherwise, render it in the normal order.
+ else {
+ $normal[$pid] = $pane;
+ }
+ }
+ $this->prepared['panes'] = $normal + $last;
+ return $this->prepared['panes'];
+ }
+
+ /**
+ * @param array $regions
+ * @param array $settings
+ */
+ function prepare_regions($region_list, $settings) {
+ // Initialize defaults to be used for regions without their own explicit
+ // settings. Use display settings if they exist, else hardcoded defaults
+ $default = array(
+ 'style' => !empty($settings['style']) ? $settings['style'] : panels_get_style('default'),
+ 'style settings' => isset($settings['style_settings']['default']) ? $settings['style_settings']['default'] : array(),
+ );
+
+ $regions = array();
+ if (empty($settings)) {
+ // No display/panel region settings exist, init all with the defaults.
+ foreach ($region_list as $region_id => $panes) {
+ $regions[$region_id] = $default;
+ $regions[$region_id]['pids'] = $panes;
+ }
+ }
+ else {
+ // Some settings exist; iterate through each region and set individually
+ foreach ($region_list as $region_id => $panes) {
+ if (empty($settings[$region_id]['style']) || $settings[$region_id]['style'] == -1) {
+ $regions[$region_id] = $default;
+ }
+ else {
+ $regions[$region_id]['style'] = panels_get_style($settings[$region_id]['style']);
+ $regions[$region_id]['style settings'] = isset($settings['style_settings'][$region_id]) ? $settings['style_settings'][$region_id] : array();
+ }
+ $regions[$region_id]['pids'] = $panes;
+ }
+ }
+ $this->prepared['regions'] = $regions;
+ return $this->prepared['regions'];
+ }
+
+ /**
+ * Build inner content, then hand off to layout-specified theme function for
+ * final render step.
+ *
+ * This is the outermost method in the Panels render pipeline. It calls the
+ * inner methods, which return a content array, which is in turn passed to the
+ * theme function specified in the layout plugin.
+ *
+ * @return string
+ * Themed & rendered HTML output.
+ */
+ function render() {
+ // Attach out-of-band data first.
+ $this->add_meta();
+
+ if (empty($this->display->cache['method'])) {
+ return $this->render_layout();
+ }
+ else {
+ $cache = panels_get_cached_content($this->display, $this->display->args, $this->display->context);
+ if ($cache === FALSE) {
+ $cache = new panels_cache_object();
+ $cache->set_content($this->render_layout());
+ panels_set_cached_content($cache, $this->display, $this->display->args, $this->display->context);
+ }
+ return $cache->content;
+ }
+ }
+
+ /**
+ * Perform display/layout-level render operations.
+ *
+ * This method triggers all the inner pane/region rendering processes, passes
+ * that to the layout plugin's theme callback, and returns the rendered HTML.
+ *
+ * If display-level caching is enabled and that cache is warm, this method
+ * will not be called.
+ */
+ function render_layout() {
+ if (empty($this->prep_run)) {
+ $this->prepare();
+ }
+ $this->render_panes();
+ $this->render_regions();
+ $this->rendered['layout'] = theme($this->plugins['layout']['theme'], check_plain($this->display->css_id), $this->rendered['regions'], $this->display->layout_settings, $this->display);
+ return $this->rendered['layout'];
+ }
+
+ /**
+ * Attach out-of-band page metadata (e.g., CSS and JS).
+ *
+ * This must be done before render, because panels-within-panels must have
+ * their CSS added in the right order: inner content before outer content.
+ */
+ function add_meta() {
+ if (!empty($this->plugins['layout']['css'])) {
+ if (file_exists(path_to_theme() . '/' . $this->plugins['layout']['css'])) {
+ drupal_add_css(path_to_theme() . '/' . $this->plugins['layout']['css']);
+ }
+ else {
+ drupal_add_css($this->plugins['layout']['path'] . '/' . $this->plugins['layout']['css']);
+ }
+ }
+ }
+
+ function render_panes() {
+ ctools_include('content');
+
+ // First, render all the panes into little boxes.
+ $this->rendered['panes'] = array();
+ foreach ($this->prepared['panes'] as $pid => $pane) {
+ $this->rendered['panes'][$pid] = $this->render_pane($pane);
+ }
+ }
+
+ /**
+ * Render a pane using the appropriate style.
+ *
+ * @param object $pane
+ * The $pane information from the display
+ */
+ function render_pane($pane) {
+ $content = $this->render_pane_content($pane);
+ if ($this->display->hide_title == PANELS_TITLE_PANE && !empty($this->display->title_pane) && $this->display->title_pane == $pane->pid) {
+
+ // If the user selected to override the title with nothing, and selected
+ // this as the title pane, assume the user actually wanted the original
+ // title to bubble up to the top but not actually be used on the pane.
+ if (empty($content->title) && !empty($content->original_title)) {
+ $this->display->stored_pane_title = $content->original_title;
+ }
+ else {
+ $this->display->stored_pane_title = !empty($content->title) ? $content->title : '';
+ }
+ }
+
+ if (!empty($pane->style['style'])) {
+ $style = panels_get_style($pane->style['style']);
+
+ if (isset($style) && isset($style['render pane'])) {
+ $output = theme($style['render pane'], $content, $pane, $this->display);
+
+ // This could be null if no theme function existed.
+ if (isset($output)) {
+ return $output;
+ }
+ }
+ }
+
+ if (!empty($content->content)) {
+ // fallback
+ return theme('panels_pane', $content, $pane, $this->display);
+ }
+ }
+
+ /**
+ * Render the contents of a single pane.
+ *
+ * This method retrieves pane content and produces a ready-to-render content
+ * object. It also manages pane-specific caching.
+ *
+ * @param stdClass $pane
+ * A Panels pane object, as loaded from the database.
+ */
+ function render_pane_content($pane) { // TODO remove this method by collapsing it into $this->render_panes()
+ ctools_include('context');
+ // TODO finally safe to remove this check?
+ if (!is_array($this->display->context)) {
+ watchdog('panels', 'renderer:render_pane_content() hit with a non-array for the context', $this->display, WATCHDOG_DEBUG);
+ $this->display->context = array();
+ }
+
+ $content = FALSE;
+ $caching = !empty($pane->cache['method']) ? TRUE : FALSE;
+ if ($caching && ($cache = panels_get_cached_content($this->display, $this->display->args, $this->display->context, $pane))) {
+ $content = $cache->content;
+ }
+ else {
+ $content = ctools_content_render($pane->type, $pane->subtype, $pane->configuration, array(), $this->display->args, $this->display->context);
+ foreach (module_implements('panels_pane_content_alter') as $module) {
+ $function = $module . '_panels_pane_content_alter';
+ $function($content, $pane, $this->display->args, $this->display->context);
+ }
+ if ($caching) {
+ $cache = new panels_cache_object();
+ $cache->set_content($content);
+ panels_set_cached_content($cache, $this->display, $this->display->args, $this->display->context, $pane);
+ $content = $cache->content;
+ }
+ }
+
+ // Pass long the css_id that is usually available.
+ if (!empty($pane->css['css_id'])) {
+ $content->css_id = $pane->css['css_id'];
+ }
+
+ // Pass long the css_class that is usually available.
+ if (!empty($pane->css['css_class'])) {
+ $content->css_class = $pane->css['css_class'];
+ }
+
+ return $content;
+ }
+
+ /**
+ * Render all panes in the attached display into their panel regions, then
+ * render those regions.
+ *
+ * @return array
+ * An array of rendered panel regions, keyed on the region name.
+ */
+ function render_regions() {
+ // Initialize the regions array with keys for each region and NULL values
+ // for each; this prevents warnings on empty regions later
+ $this->rendered['regions'] = array();
+ foreach (array_keys($this->plugins['layout']['panels']) as $region_id) {
+ $this->rendered['regions'][$region_id] = NULL;
+ }
+
+ // Loop through all panel regions, put all panes that belong to the current
+ // region in an array, then render the region. Primarily this ensures that
+ // the panes are arranged in the proper order.
+ $content = array();
+ foreach ($this->prepared['regions'] as $region_id => $conf) {
+ $region_panes = array();
+ foreach ($conf['pids'] as $pid) {
+ // Only include panes for region rendering if they had some output.
+ if (!empty($this->rendered['panes'][$pid])) {
+ $region_panes[$pid] = $this->rendered['panes'][$pid];
+ }
+ }
+ $this->rendered['regions'][$region_id] = $this->render_region($region_id, $region_panes);
+ }
+
+ return $this->rendered['regions'];
+ }
+
+ /**
+ * Render a single panel region.
+ *
+ * Primarily just a passthrough to the panel region rendering callback
+ * specified by the style plugin that is attached to the current panel region.
+ *
+ * @param $region_id
+ * The ID of the panel region being rendered
+ * @param $panes
+ * An array of panes that are assigned to the panel that's being rendered.
+ *
+ * @return string
+ * The rendered, HTML string output of the passed-in panel region.
+ */
+ function render_region($region_id, $panes) {
+ $style = $this->prepared['regions'][$region_id]['style'];
+ $style_settings = $this->prepared['regions'][$region_id]['style settings'];
+
+ // Retrieve the pid (can be a panel page id, a mini panel id, etc.), this
+ // might be used (or even necessary) for some panel display styles.
+ // TODO: Got to fix this to use panel page name instead of pid, since pid is
+ // no longer guaranteed. This needs an API to be able to set the final id.
+ $owner_id = 0;
+ if (isset($this->display->owner) && is_object($this->display->owner) && isset($this->display->owner->id)) {
+ $owner_id = $this->display->owner->id;
+ }
+
+ return theme($style['render region'], $this->display, $owner_id, $panes, $style_settings, $region_id);
+ }
+}
diff --git plugins/display_renderers/panels_renderer_default.inc plugins/display_renderers/panels_renderer_default.inc
new file mode 100644
index 0000000..707c532
--- /dev/null
+++ plugins/display_renderers/panels_renderer_default.inc
@@ -0,0 +1,7 @@
+ array(
+ 'class' => 'panels_renderer_default',
+ ),
+);
\ No newline at end of file
diff --git plugins/display_renderers/panels_renderer_legacy.class.php plugins/display_renderers/panels_renderer_legacy.class.php
new file mode 100644
index 0000000..67e135a
--- /dev/null
+++ plugins/display_renderers/panels_renderer_legacy.class.php
@@ -0,0 +1,222 @@
+layout);
+ $this->display = &$display;
+ $this->plugins['layout'] = $layout;
+ }
+
+ /**
+ * Builds inner content, then hands off to layout-specified theme function for
+ * final render step.
+ *
+ * This is the outermost method in the Panels render pipeline. It calls the
+ * inner methods, which return a content array, which is in turn passed to the
+ * theme function specified in the layout plugin.
+ *
+ * @return string
+ * Themed & rendered HTML output.
+ */
+ function render() {
+ if (!empty($this->plugins['layout']['css'])) {
+ if (file_exists(path_to_theme() . '/' . $this->plugins['layout']['css'])) {
+ drupal_add_css(path_to_theme() . '/' . $this->plugins['layout']['css']);
+ }
+ else {
+ drupal_add_css($this->plugins['layout']['path'] . '/' . $this->plugins['layout']['css']);
+ }
+ }
+ // This now comes after the CSS is added, because panels-within-panels must
+ // have their CSS added in the right order; inner content before outer content.
+
+ if (empty($this->display->cache['method'])) {
+ $content = $this->render_regions();
+ }
+ else {
+ $cache = panels_get_cached_content($this->display, $this->display->args, $this->display->context);
+ if ($cache === FALSE) {
+ $cache = new panels_cache_object();
+ $cache->set_content($this->render_regions());
+ panels_set_cached_content($cache, $this->display, $this->display->args, $this->display->context);
+ }
+ $content = $cache->content;
+ }
+
+ $output = theme($this->plugins['layout']['theme'], check_plain($this->display->css_id), $content, $this->display->layout_settings, $this->display);
+
+ return $output;
+ }
+
+ /**
+ * Render all panes in the attached display into their panel regions, then
+ * render those regions.
+ *
+ * @return array $content
+ * An array of rendered panel regions, keyed on the region name.
+ */
+ function render_regions() {
+ ctools_include('content');
+
+ // First, render all the panes into little boxes. We do this here because
+ // some panes request to be rendered after other panes (primarily so they
+ // can do the leftovers of forms).
+ $panes = array();
+ $later = array();
+
+ foreach ($this->display->content as $pid => $pane) {
+ $pane->shown = !empty($pane->shown); // guarantee this field exists.
+ // If the user can't see this pane, do not render it.
+ if (!$pane->shown || !panels_pane_access($pane, $this->display)) {
+ continue;
+ }
+
+ // If this pane wants to render last, add it to the $later array.
+ $content_type = ctools_get_content_type($pane->type);
+
+ if (!empty($content_type['render last'])) {
+ $later[$pid] = $pane;
+ continue;
+ }
+
+ $panes[$pid] = $this->render_pane($pane);
+ }
+
+ foreach ($later as $pid => $pane) {
+ $panes[$pid] = $this->render_pane($pane);
+ }
+
+ // Loop through all panels, put all panes that belong to the current panel
+ // in an array, then render the panel. Primarily this ensures that the
+ // panes are in the proper order.
+ $content = array();
+ foreach ($this->display->panels as $panel_name => $pids) {
+ $panel_panes = array();
+ foreach ($pids as $pid) {
+ if (!empty($panes[$pid])) {
+ $panel_panes[$pid] = $panes[$pid];
+ }
+ }
+ $content[$panel_name] = $this->render_region($panel_name, $panel_panes);
+ }
+
+ // Prevent notices by making sure that all panels at least have an entry:
+ $panels = panels_get_panels($this->plugins['layout'], $this->display);
+ foreach ($panels as $id => $panel) {
+ if (!isset($content[$id])) {
+ $content[$id] = NULL;
+ }
+ }
+
+ return $content;
+ }
+
+ /**
+ * Render the contents of a single pane.
+ *
+ * This method retrieves pane content and produces a ready-to-render content
+ * object. It also manages pane-specific caching.
+ *
+ * @param stdClass $pane
+ * A Panels pane object, as loaded from the database.
+ */
+ function render_pane($pane) {
+ ctools_include('context');
+ if (!is_array($this->display->context)) {
+ $this->display->context = array();
+ }
+
+ $content = FALSE;
+ $caching = !empty($pane->cache['method']) ? TRUE : FALSE;
+ if ($caching && ($cache = panels_get_cached_content($this->display, $this->display->args, $this->display->context, $pane))) {
+ $content = $cache->content;
+ }
+ else {
+ $content = ctools_content_render($pane->type, $pane->subtype, $pane->configuration, array(), $this->display->args, $this->display->context);
+ foreach (module_implements('panels_pane_content_alter') as $module) {
+ $function = $module . '_panels_pane_content_alter';
+ $function($content, $pane, $this->display->args, $this->display->context);
+ }
+ if ($caching) {
+ $cache = new panels_cache_object();
+ $cache->set_content($content);
+ panels_set_cached_content($cache, $this->display, $this->display->args, $this->display->context, $pane);
+ $content = $cache->content;
+ }
+ }
+
+ // Pass long the css_id that is usually available.
+ if (!empty($pane->css['css_id'])) {
+ $content->css_id = $pane->css['css_id'];
+ }
+
+ // Pass long the css_class that is usually available.
+ if (!empty($pane->css['css_class'])) {
+ $content->css_class = $pane->css['css_class'];
+ }
+
+ return $content;
+ }
+
+ /**
+ * Render a single panel region.
+ *
+ * Primarily just a passthrough to the panel region rendering callback
+ * specified by the style plugin that is attached to the current panel region.
+ *
+ * @param $region_name
+ * The ID of the panel region being rendered
+ * @param $panes
+ * An array of panes that are assigned to the panel that's being rendered.
+ *
+ * @return
+ * The rendered HTML for the passed-in panel region.
+ */
+ function render_region($region_name, $panes) {
+ list($style, $style_settings) = panels_get_panel_style_and_settings($this->display->panel_settings, $region_name);
+ $callback = 'render panel';
+
+ // Retrieve the pid (can be a panel page id, a mini panel id, etc.), this
+ // might be used (or even necessary) for some panel display styles.
+ $owner_id = 0;
+ if (isset($this->display->owner) && is_object($this->display->owner) && isset($this->display->owner->id)) {
+ $owner_id = $this->display->owner->id;
+ }
+
+ // Check to see if we're actually running a current style plugin even though
+ // we're in the legacy renderer
+ if (version_compare($style['version'], 2.0, '>=')) {
+ // We are, so pre-render the content as the current version expects
+ foreach($panes as $pane_id => $pane) {
+ $panes[$pane_id] = panels_render_pane($pane, $this->display->content[$pane_id], $this->display);
+ }
+ // And set the callback to the new key
+ $callback = 'render region';
+
+ }
+ dsm($panes);
+
+ return theme($style[$callback], $this->display, $owner_id, $panes, $style_settings, $region_name);
+ }
+}
diff --git plugins/display_renderers/panels_renderer_legacy.inc plugins/display_renderers/panels_renderer_legacy.inc
new file mode 100644
index 0000000..2082105
--- /dev/null
+++ plugins/display_renderers/panels_renderer_legacy.inc
@@ -0,0 +1,7 @@
+ array(
+ 'class' => 'panels_renderer_legacy',
+ ),
+);
\ No newline at end of file
diff --git plugins/display_renderers/panels_renderer_single_pane.class.php plugins/display_renderers/panels_renderer_single_pane.class.php
new file mode 100644
index 0000000..4d022c8
--- /dev/null
+++ plugins/display_renderers/panels_renderer_single_pane.class.php
@@ -0,0 +1,35 @@
+display = &$display;
+ }
+
+ function prepare($external_settings = NULL) {
+ $this->render_pid = $external_settings;
+ }
+
+ function render() {
+ // If no requested pid, or requested pid does not exist,
+ if (empty($this->render_pid) || empty($this->display->content[$this->render_pid])) {
+ return NULL;
+ }
+ return $this->render_pane($this->display->content[$this->render_pid]);
+ }
+
+ function render_single($pid) {
+ return $this->render_pane($this->display->content[$pid]);
+ }
+}
\ No newline at end of file
diff --git plugins/display_renderers/panels_renderer_single_pane.inc plugins/display_renderers/panels_renderer_single_pane.inc
new file mode 100644
index 0000000..e0576ff
--- /dev/null
+++ plugins/display_renderers/panels_renderer_single_pane.inc
@@ -0,0 +1,8 @@
+ array(
+ 'class' => 'panels_renderer_single_pane',
+ 'parent' => 'panels_renderer_default',
+ ),
+);
\ No newline at end of file
diff --git plugins/styles/corners/rounded_corners.inc plugins/styles/corners/rounded_corners.inc
index 0dd7db7..dd99bd4 100644
--- plugins/styles/corners/rounded_corners.inc
+++ plugins/styles/corners/rounded_corners.inc
@@ -9,8 +9,8 @@
// Plugin definition
$plugin = array(
'title' => t('Rounded corners'),
- 'description' => t('Presents the panes or panels with a rounded corner box around them'),
- 'render panel' => 'panels_rounded_corners_style_render_panel',
+ 'description' => t('Presents the panes or panel regions with a rounded corner box around them'),
+ 'render region' => 'panels_rounded_corners_style_render_region',
'render pane' => 'panels_rounded_corners_style_render_pane',
'settings form' => 'panels_rounded_corners_style_settings_form',
'hook theme' => array(
@@ -27,7 +27,7 @@ $plugin = array(
*
* @ingroup themeable
*/
-function theme_panels_rounded_corners_style_render_panel($display, $panel_id, $panes, $settings) {
+function theme_panels_rounded_corners_style_render_region($display, $region_id, $panes, $settings) {
$output = '';
// Determine where to put the box. If empty or 'pane' around each pane. If
@@ -35,19 +35,18 @@ function theme_panels_rounded_corners_style_render_panel($display, $panel_id, $p
$where = empty($settings['corner_location']) ? 'pane' : $settings['corner_location'];
$print_separator = FALSE;
- foreach ($panes as $pane_id => $pane) {
- $text = panels_render_pane($pane, $display->content[$pane_id], $display);
- if ($text) {
+ foreach ($panes as $pane_id => $pane_output) {
+ if ($pane_output) {
// Add the separator if we've already displayed a pane.
if ($print_separator) {
- $output .= '