' . $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, array());
+ 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, $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..a50a86b
--- /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..5474db7
--- /dev/null
+++ panels_ipe/plugins/display_renderers/panels_renderer_ipe.inc
@@ -0,0 +1,8 @@
+ array(
+ 'class' => 'panels_renderer_ipe',
+ 'parent' => 'panels_renderer_standard',
+ ),
+);
\ No newline at end of file
diff --git panels_ipe/plugins/display_renderers/panels_renderer_single_pane.class.php panels_ipe/plugins/display_renderers/panels_renderer_single_pane.class.php
new file mode 100644
index 0000000..2fdd76d
--- /dev/null
+++ panels_ipe/plugins/display_renderers/panels_renderer_single_pane.class.php
@@ -0,0 +1,31 @@
+display = &$display;
+ $this->render_pid = $pid;
+ }
+
+ function render() {
+ // If the requested pid does not exist,
+ if (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 panels_ipe/plugins/display_renderers/panels_renderer_single_pane.inc panels_ipe/plugins/display_renderers/panels_renderer_single_pane.inc
new file mode 100644
index 0000000..d284239
--- /dev/null
+++ panels_ipe/plugins/display_renderers/panels_renderer_single_pane.inc
@@ -0,0 +1,8 @@
+ array(
+ 'class' => 'panels_renderer_single_pane',
+ 'parent' => 'panels_renderer_standard',
+ ),
+);
\ 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 plugins/display_renderers/panels_renderer_legacy.class.php plugins/display_renderers/panels_renderer_legacy.class.php
new file mode 100644
index 0000000..cfe9195
--- /dev/null
+++ plugins/display_renderers/panels_renderer_legacy.class.php
@@ -0,0 +1,238 @@
+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() {
+ // TODO can probably make this early-add CSS business go away by making
+ // mini panels use a slightly different plugin
+ 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 {
+ // TODO This whole approach can & probably should be refactored now. Maybe
+ // invert it, and have the caching agent act from the outside?
+ $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) {
+ // 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 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:
+ // TODO refactor to make this unnecessary (optimization)
+ $panels = panels_get_panels($this->plugins['layout'], $this->display);
+ foreach ($panels as $id => $panel) {
+ if (!isset($content[$id])) {
+ $content[$id] = NULL;
+ }
+ }
+
+ return $content;
+ }
+
+ /**
+ * 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);
+
+ // 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'];
+ }
+ }
+
+ /**
+ * 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)) {
+ $this->display->context = array();
+ }
+
+ // TODO this should be moved up to fully cache styled output, rather than
+ // just rendered output; no reason to reevaluaate all that every time
+ $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);
+
+ // 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 panel'], $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_standard.class.php plugins/display_renderers/panels_renderer_standard.class.php
new file mode 100644
index 0000000..4231ac5
--- /dev/null
+++ plugins/display_renderers/panels_renderer_standard.class.php
@@ -0,0 +1,372 @@
+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.
+ */
+ function prepare() {
+ $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'];
+ }
+
+ /**
+ * 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() {
+ $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;
+ }
+ }
+
+ 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 panel'], $this->display, $owner_id, $panes, $style_settings, $region_id);
+ }
+}
diff --git plugins/display_renderers/panels_renderer_standard.inc plugins/display_renderers/panels_renderer_standard.inc
new file mode 100644
index 0000000..39b235d
--- /dev/null
+++ plugins/display_renderers/panels_renderer_standard.inc
@@ -0,0 +1,7 @@
+ array(
+ 'class' => 'panels_renderer_standard',
+ ),
+);
\ No newline at end of file
diff --git plugins/styles/corners/rounded_corners.inc plugins/styles/corners/rounded_corners.inc
index 0dd7db7..84f7fa0 100644
--- plugins/styles/corners/rounded_corners.inc
+++ plugins/styles/corners/rounded_corners.inc
@@ -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 .= '