/products/photocrati_nextgen/modules/nextgen_basic_album/package.module.nextgen_basic_album.php

  1. <?php 
  2. /** 
  3.  * Class A_NextGen_Album_Breadcrumbs 
  4.  * @mixin C_MVC_View 
  5.  * @adapts I_MVC_View 
  6.  */ 
  7. class A_NextGen_Album_Breadcrumbs extends Mixin 
  8. { 
  9.   public $breadcrumb_cache = array(); 
  10.   function are_breadcrumbs_enabled($display_settings) 
  11.   { 
  12.       $retval = FALSE; 
  13.       if (isset($display_settings['enable_breadcrumbs']) && $display_settings['enable_breadcrumbs']) { 
  14.           $retval = TRUE; 
  15.       } elseif (isset($display_settings['original_settings']) && $this->are_breadcrumbs_enabled($display_settings['original_settings'])) { 
  16.           $retval = TRUE; 
  17.       } 
  18.       return $retval; 
  19.   } 
  20.   function get_original_album_entities($display_settings) 
  21.   { 
  22.       $retval = array(); 
  23.       if (isset($display_settings['original_album_entities'])) { 
  24.           $retval = $display_settings['original_album_entities']; 
  25.       } elseif (isset($display_settings['original_settings']) && $this->get_original_album_entities($display_settings['original_settings'])) { 
  26.           $retval = $this->get_original_album_entities($display_settings['original_settings']); 
  27.       } 
  28.       return $retval; 
  29.   } 
  30.   function render_object() 
  31.   { 
  32.       $root_element = $this->call_parent('render_object'); 
  33.       if ($displayed_gallery = $this->object->get_param('displayed_gallery')) { 
  34.           $ds = $displayed_gallery->display_settings; 
  35.           if ($this->are_breadcrumbs_enabled($ds) && ($original_entities = $this->get_original_album_entities($ds))) { 
  36.               $original_entities = $this->get_original_album_entities($ds); 
  37.               if (!empty($ds['original_album_id'])) { 
  38.                   $ids = $ds['original_album_id']; 
  39.               } else { 
  40.                   $ids = $displayed_gallery->container_ids; 
  41.               } 
  42.               $breadcrumbs = $this->object->generate_breadcrumb($ids, $original_entities); 
  43.               foreach ($root_element->find('nextgen_gallery.gallery_container', TRUE) as $container) { 
  44.                   $container->insert($breadcrumbs); 
  45.               } 
  46.           } 
  47.       } 
  48.       return $root_element; 
  49.   } 
  50.   function render_legacy_template_breadcrumbs($displayed_gallery, $entities, $gallery_id = FALSE) 
  51.   { 
  52.       $ds = $displayed_gallery->display_settings; 
  53.       if (!empty($entities) && !empty($ds['template']) && $this->are_breadcrumbs_enabled($ds)) { 
  54.           if ($gallery_id) { 
  55.               if (is_array($gallery_id)) { 
  56.                   $ids = $gallery_id; 
  57.               } else { 
  58.                   $ids = array($gallery_id); 
  59.               } 
  60.           } elseif (!empty($ds['original_album_id'])) { 
  61.               $ids = $ds['original_album_id']; 
  62.           } else { 
  63.               $ids = $displayed_gallery->container_ids; 
  64.           } 
  65.           if (!empty($ds['original_album_entities'])) { 
  66.               $breadcrumb_entities = $ds['original_album_entities']; 
  67.           } else { 
  68.               $breadcrumb_entities = $entities; 
  69.           } 
  70.           return $this->object->generate_breadcrumb($ids, $breadcrumb_entities); 
  71.       } else { 
  72.           return ''; 
  73.       } 
  74.   } 
  75.   function find_gallery_parent($gallery_id, $sortorder) 
  76.   { 
  77.       $map = C_Album_Mapper::get_instance(); 
  78.       $found = array(); 
  79.       foreach ($sortorder as $order) { 
  80.           if (strpos($order, 'a') === 0) { 
  81.               $album_id = ltrim($order, 'a'); 
  82.               if (empty($this->breadcrumb_cache[$order])) { 
  83.                   $album = $map->find($album_id); 
  84.                   $this->breadcrumb_cache[$order] = $album; 
  85.                   if (in_array($gallery_id, $album->sortorder)) { 
  86.                       $found[] = $album; 
  87.                       break; 
  88.                   } else { 
  89.                       $found = $this->find_gallery_parent($gallery_id, $album->sortorder, $found); 
  90.                       if ($found) { 
  91.                           $found[] = $album; 
  92.                           break; 
  93.                       } 
  94.                   } 
  95.               } 
  96.           } 
  97.       } 
  98.       return $found; 
  99.   } 
  100.   function generate_breadcrumb($gallery_id = NULL, $entities) 
  101.   { 
  102.       $found = array(); 
  103.       $router = C_Router::get_instance(); 
  104.       $app = $router->get_routed_app(); 
  105.       if (is_array($gallery_id)) { 
  106.           $gallery_id = array_shift($gallery_id); 
  107.       } 
  108.       if (is_array($gallery_id)) { 
  109.           $gallery_id = $gallery_id[0]; 
  110.       } 
  111.       foreach ($entities as $ndx => $entity) { 
  112.           $tmpid = (isset($entity->albumdesc) ? 'a' : '') . $entity->{$entity->id_field}; 
  113.           $this->breadcrumb_cache[$tmpid] = $entity; 
  114.           if (isset($entity->albumdesc) && in_array($gallery_id, $entity->sortorder)) { 
  115.               $found[] = $entity; 
  116.               break; 
  117.           } 
  118.       } 
  119.       if (empty($found)) { 
  120.           foreach ($entities as $entity) { 
  121.               if (!empty($entity->sortorder)) { 
  122.                   $found = $this->object->find_gallery_parent($gallery_id, $entity->sortorder); 
  123.               } 
  124.               if (!empty($found)) { 
  125.                   $found[] = $entity; 
  126.                   break; 
  127.               } 
  128.           } 
  129.       } 
  130.       $found = array_reverse($found); 
  131.       if (strpos($gallery_id, 'a') === 0) { 
  132.           $album_found = FALSE; 
  133.           foreach ($found as $found_item) { 
  134.               if ($found_item->{$found_item->id_field} == $gallery_id) { 
  135.                   $album_found = TRUE; 
  136.               } 
  137.           } 
  138.           if (!$album_found) { 
  139.               $album_id = ltrim($gallery_id, 'a'); 
  140.               $album = C_Album_Mapper::get_instance()->find($album_id); 
  141.               $found[] = $album; 
  142.               $this->breadcrumb_cache[$gallery_id] = $album; 
  143.           } 
  144.       } else { 
  145.           $gallery_found = FALSE; 
  146.           foreach ($entities as $entity) { 
  147.               if (isset($entity->is_gallery) && $entity->is_gallery && $gallery_id == $entity->{$entity->id_field}) { 
  148.                   $gallery_found = TRUE; 
  149.                   $found[] = $entity; 
  150.                   break; 
  151.               } 
  152.           } 
  153.           if (!$gallery_found) { 
  154.               $gallery = C_Gallery_Mapper::get_instance()->find($gallery_id); 
  155.               if ($gallery != null) { 
  156.                   $found[] = $gallery; 
  157.                   $this->breadcrumb_cache[$gallery->{$gallery->id_field}] = $gallery; 
  158.               } 
  159.           } 
  160.       } 
  161.       $crumbs = array(); 
  162.       if (!empty($found)) { 
  163.           $end = end($found); 
  164.           reset($found); 
  165.           foreach ($found as $found_item) { 
  166.               $type = isset($found_item->albumdesc) ? 'album' : 'gallery'; 
  167.               $id = ($type == 'album' ? 'a' : '') . $found_item->{$found_item->id_field}; 
  168.               $entity = $this->breadcrumb_cache[$id]; 
  169.               $link = NULL; 
  170.               if ($type == 'album') { 
  171.                   $name = $entity->name; 
  172.                   if ($entity->pageid > 0) { 
  173.                       $link = @get_page_link($entity->pageid); 
  174.                   } 
  175.                   if (empty($link) && $found_item !== $end) { 
  176.                       $link = $app->get_routed_url(); 
  177.                       $link = $app->strip_param_segments($link); 
  178.                       $link = $app->set_parameter_value('album', $entity->slug, NULL, FALSE, $link); 
  179.                   } 
  180.               } else { 
  181.                   $name = $entity->title; 
  182.               } 
  183.               $crumbs[] = array('type' => $type, 'name' => $name, 'url' => $link); 
  184.           } 
  185.       } 
  186.       // free this memory immediately 
  187.       $this->breadcrumb_cache = array(); 
  188.       $view = new C_MVC_View('photocrati-nextgen_basic_album#breadcrumbs', array('breadcrumbs' => $crumbs, 'divisor' => apply_filters('ngg_breadcrumb_separator', ' » '))); 
  189.       return $view->render(TRUE); 
  190.   } 
  191. } 
  192. /** 
  193.  * Because enqueueing an albums child entities (for use in lightboxes) is slow to do inside of cache_action() and 
  194.  * we can't guarantee index_action() will run on every hit (thanks to page caching) we inline those entities into 
  195.  * our basic albums templates under a window.load listener. 
  196.  * 
  197.  * @mixin C_MVC_View 
  198.  * @adapts I_MVC_View 
  199.  */ 
  200. class A_NextGen_Album_Child_Entities extends Mixin 
  201. { 
  202.   protected static $_runonce = FALSE; 
  203.   public static $_entities = array(); 
  204.   /** 
  205.    * The album controller will invoke this filter when its _render_album() method is called 
  206.    */ 
  207.   function __construct() 
  208.   { 
  209.       if (!self::$_runonce) { 
  210.           add_filter('ngg_album_prepared_child_entity', array($this, 'register_child_gallery'), 10, 2); 
  211.       } else { 
  212.           self::$_runonce = TRUE; 
  213.       } 
  214.   } 
  215.   /** 
  216.    * Register each gallery belonging to the album that has just been rendered, so that when the MVC controller 
  217.    * system 'catches up' and runs $this->render_object() that method knows what galleries to inline as JS. 
  218.    * 
  219.    * @param array $gallery 
  220.    * @param $displayed_gallery 
  221.    * @return array mixed 
  222.    */ 
  223.   function register_child_gallery($galleries, $displayed_gallery) 
  224.   { 
  225.       if (!$this->is_basic_album($displayed_gallery)) { 
  226.           return $galleries; 
  227.       } 
  228.       $id = $displayed_gallery->ID(); 
  229.       foreach ($galleries as $gallery) { 
  230.           if ($gallery->is_album) { 
  231.               continue; 
  232.           } 
  233.           self::$_entities[$id][] = $gallery; 
  234.       } 
  235.       return $galleries; 
  236.   } 
  237.   function is_basic_album($displayed_gallery) 
  238.   { 
  239.       return in_array($displayed_gallery->display_type, array(NGG_BASIC_COMPACT_ALBUM, NGG_BASIC_EXTENDED_ALBUM)); 
  240.   } 
  241.   /** 
  242.    * Determine if we need to append the JS to the current template. This method static for the basic album controller to access. 
  243.    * 
  244.    * @param $display_settings 
  245.    * @return bool 
  246.    */ 
  247.   static function are_child_entities_enabled($display_settings) 
  248.   { 
  249.       $retval = FALSE; 
  250.       if (empty($display_settings['open_gallery_in_lightbox'])) { 
  251.           $display_settings['open_gallery_in_lightbox'] = 0; 
  252.       } 
  253.       if ($display_settings['open_gallery_in_lightbox'] == 1) { 
  254.           $retval = TRUE; 
  255.       } 
  256.       return $retval; 
  257.   } 
  258.   /** 
  259.    * Search inside the template for the inside of the container and append our inline JS 
  260.    */ 
  261.   function render_object() 
  262.   { 
  263.       $root_element = $this->call_parent('render_object'); 
  264.       if ($displayed_gallery = $this->object->get_param('displayed_gallery')) { 
  265.           if (!$this->is_basic_album($displayed_gallery)) { 
  266.               return $root_element; 
  267.           } 
  268.           $ds = $displayed_gallery->display_settings; 
  269.           if (self::are_child_entities_enabled($ds)) { 
  270.               $id = $displayed_gallery->ID(); 
  271.               foreach ($root_element->find('nextgen_gallery.gallery_container', TRUE) as $container) { 
  272.                   $container->append(self::generate_script(self::$_entities[$id])); 
  273.               } 
  274.           } 
  275.       } 
  276.       return $root_element; 
  277.   } 
  278.   /** 
  279.    * Generate the JS that will be inserted into the template. This method static for the basic album controller to access. 
  280.    * 
  281.    * @param array $galleries 
  282.    * @return string 
  283.    */ 
  284.   static function generate_script($galleries) 
  285.   { 
  286.       $retval = '<script type="text/javascript">window.addEventListener("load", function() {'; 
  287.       foreach ($galleries as $gallery) { 
  288.           $dg = $gallery->displayed_gallery; 
  289.           $id = $dg->id(); 
  290.           $retval .= 'galleries.gallery_' . $id . ' = ' . json_encode($dg->get_entity()) . ';'; 
  291.           $retval .= 'galleries.gallery_' . $id . '.wordpress_page_root = "' . get_permalink() . '";'; 
  292.       } 
  293.       $retval .= '}, false);</script>'; 
  294.       return $retval; 
  295.   } 
  296. } 
  297. /** 
  298.  * Class A_NextGen_Album_Descriptions 
  299.  * @mixin C_MVC_View 
  300.  * @adapts I_MVC_View 
  301.  */ 
  302. class A_NextGen_Album_Descriptions extends Mixin 
  303. { 
  304.   // When viewing a child gallery the album controller's add_description_to_legacy_templates() method will be 
  305.   // called for the gallery and then again for the root album; we only want to run once 
  306.   public static $_description_added_once = FALSE; 
  307.   function are_descriptions_enabled($display_settings) 
  308.   { 
  309.       $retval = FALSE; 
  310.       if (isset($display_settings['enable_descriptions']) && $display_settings['enable_descriptions']) { 
  311.           $retval = TRUE; 
  312.       } elseif (isset($display_settings['original_settings']) && $this->are_descriptions_enabled($display_settings['original_settings'])) { 
  313.           $retval = TRUE; 
  314.       } 
  315.       return $retval; 
  316.   } 
  317.   function render_object() 
  318.   { 
  319.       $root_element = $this->call_parent('render_object'); 
  320.       if ($displayed_gallery = $this->object->get_param('displayed_gallery')) { 
  321.           $ds = $displayed_gallery->display_settings; 
  322.           if ($this->are_descriptions_enabled($ds)) { 
  323.               $description = $this->object->generate_description($displayed_gallery); 
  324.               foreach ($root_element->find('nextgen_gallery.gallery_container', TRUE) as $container) { 
  325.                   // Determine where (to be compatible with breadcrumbs) in the container to insert 
  326.                   $pos = 0; 
  327.                   foreach ($container->_list as $ndx => $item) { 
  328.                       if (is_string($item)) { 
  329.                           $pos = $ndx; 
  330.                       } else { 
  331.                           break; 
  332.                       } 
  333.                   } 
  334.                   $container->insert($description, $pos); 
  335.               } 
  336.           } 
  337.       } 
  338.       return $root_element; 
  339.   } 
  340.   function render_legacy_template_description($displayed_gallery) 
  341.   { 
  342.       if (!empty($displayed_gallery->display_settings['template']) && $this->are_descriptions_enabled($displayed_gallery->display_settings)) { 
  343.           return $this->object->generate_description($displayed_gallery); 
  344.       } else { 
  345.           return ''; 
  346.       } 
  347.   } 
  348.   function generate_description($displayed_gallery) 
  349.   { 
  350.       if (self::$_description_added_once) { 
  351.           return ''; 
  352.       } 
  353.       self::$_description_added_once = TRUE; 
  354.       $description = $this->get_description($displayed_gallery); 
  355.       $view = new C_MVC_View('photocrati-nextgen_basic_album#descriptions', array('description' => $description)); 
  356.       return $view->render(TRUE); 
  357.   } 
  358.   function get_description($displayed_gallery) 
  359.   { 
  360.       $description = ''; 
  361.       // Important: do not array_shift() $displayed_gallery->container_ids as it will affect breadcrumbs 
  362.       $container_ids = $displayed_gallery->container_ids; 
  363.       if ($displayed_gallery->source == 'galleries') { 
  364.           $gallery_id = array_shift($container_ids); 
  365.           $gallery = C_Gallery_Mapper::get_instance()->find($gallery_id); 
  366.           if ($gallery && !empty($gallery->galdesc)) { 
  367.               $description = $gallery->galdesc; 
  368.           } 
  369.       } else { 
  370.           if ($displayed_gallery->source == 'albums') { 
  371.               $album_id = array_shift($container_ids); 
  372.               $album = C_Album_Mapper::get_instance()->find($album_id); 
  373.               if ($album && !empty($album->albumdesc)) { 
  374.                   $description = $album->albumdesc; 
  375.               } 
  376.           } 
  377.       } 
  378.       return $description; 
  379.   } 
  380. } 
  381. /** 
  382.  * Provides validation for NextGen Basic Albums 
  383.  * @mixin C_Album_Mapper 
  384.  * @adapts I_Album_Mapper 
  385.  */ 
  386. class A_NextGen_Basic_Album extends Mixin 
  387. { 
  388.   function validation() 
  389.   { 
  390.       $ngglegacy_albums = array(NGG_BASIC_COMPACT_ALBUM, NGG_BASIC_EXTENDED_ALBUM); 
  391.       if (in_array($this->object->name, $ngglegacy_albums)) { 
  392.           $this->object->validates_presence_of('gallery_display_type'); 
  393.           $this->object->validates_numericality_of('galleries_per_page'); 
  394.       } 
  395.       return $this->call_parent('validation'); 
  396.   } 
  397.   function get_order() 
  398.   { 
  399.       return NGG_DISPLAY_PRIORITY_BASE + NGG_DISPLAY_PRIORITY_STEP; 
  400.   } 
  401. } 
  402. /** 
  403.  * Class A_NextGen_Basic_Album_Controller 
  404.  * @mixin C_Display_Type_Controller 
  405.  * @adapts I_Display_Type_Controller 
  406.  */ 
  407. class A_NextGen_Basic_Album_Controller extends Mixin_NextGen_Basic_Pagination 
  408. { 
  409.   var $albums = array(); 
  410.   /** 
  411.    * Renders the front-end for the NextGen Basic Album display type 
  412.    * 
  413.    * @param $displayed_gallery 
  414.    * @param bool $return 
  415.    */ 
  416.   function index_action($displayed_gallery, $return = FALSE) 
  417.   { 
  418.       $display_settings = $displayed_gallery->display_settings; 
  419.       // We need to fetch the album containers selected in the Attach 
  420.       // to Post interface. We need to do this, because once we fetch the 
  421.       // included entities, we need to iterate over each entity and assign it 
  422.       // a parent_id, which is the album that it belongs to. We need to do this 
  423.       // because the link to the gallery, is not /nggallery/gallery--id, but 
  424.       // /nggallery/album--id/gallery--id 
  425.       $parent_albums = $displayed_gallery->get_albums(); 
  426.       // Are we to display a gallery? Ensure our 'gallery' isn't just a paginated album view 
  427.       $gallery = $gallery_slug = $this->param('gallery'); 
  428.       if ($gallery && strpos($gallery, 'nggpage--') !== 0) { 
  429.           // basic albums only support one per post 
  430.           if (isset($GLOBALS['nggShowGallery'])) { 
  431.               return; 
  432.           } 
  433.           $GLOBALS['nggShowGallery'] = TRUE; 
  434.           // Try finding the gallery by slug first. If nothing is found, we assume that 
  435.           // the user passed in a gallery id instead 
  436.           $mapper = C_Gallery_Mapper::get_instance(); 
  437.           $tmp = $mapper->select()->where(array('slug = %s', $gallery))->limit(1)->run_query(); 
  438.           $result = reset($tmp); 
  439.           unset($tmp); 
  440.           if ($result) { 
  441.               $gallery = $result->{$result->id_field}; 
  442.           } 
  443.           $renderer = C_Displayed_Gallery_Renderer::get_instance('inner'); 
  444.           $gallery_params = array('source' => 'galleries', 'container_ids' => array($gallery), 'display_type' => $display_settings['gallery_display_type'], 'original_display_type' => $displayed_gallery->display_type, 'original_settings' => $display_settings, 'original_album_entities' => $parent_albums); 
  445.           if (!empty($display_settings['gallery_display_template'])) { 
  446.               $gallery_params['template'] = $display_settings['gallery_display_template']; 
  447.           } 
  448.           add_filter('ngg_displayed_gallery_rendering', array($this, 'add_description_to_legacy_templates'), 8, 2); 
  449.           add_filter('ngg_displayed_gallery_rendering', array($this, 'add_breadcrumbs_to_legacy_templates'), 9, 2); 
  450.           $output = $renderer->display_images($gallery_params, $return); 
  451.           remove_filter('ngg_displayed_gallery_rendering', array($this, 'add_breadcrumbs_to_legacy_templates')); 
  452.           remove_filter('ngg_displayed_gallery_rendering', array($this, 'add_description_to_legacy_templates')); 
  453.           return $output; 
  454.       } else { 
  455.           if ($album = $this->param('album')) { 
  456.               $mapper = C_Album_Mapper::get_instance(); 
  457.               $result = $mapper->select()->where(array('slug = %s', $album))->limit(1)->run_query(); 
  458.               $result = array_pop($result); 
  459.               $album_sub = $result ? $result->{$result->id_field} : null; 
  460.               if ($album_sub != null) { 
  461.                   $album = $album_sub; 
  462.               } 
  463.               $displayed_gallery->entity_ids = array(); 
  464.               $displayed_gallery->sortorder = array(); 
  465.               $displayed_gallery->container_ids = ($album === '0' or $album === 'all') ? array() : array($album); 
  466.               $displayed_gallery->display_settings['original_album_id'] = 'a' . $album_sub; 
  467.               $displayed_gallery->display_settings['original_album_entities'] = $parent_albums; 
  468.           } 
  469.       } 
  470.       // Get the albums 
  471.       // TODO: This should probably be moved to the elseif block above 
  472.       $this->albums = $displayed_gallery->get_albums(); 
  473.       // None of the above: Display the main album. Get the settings required for display 
  474.       $current_page = (int) $this->param('page', $displayed_gallery->id(), 1); 
  475.       $offset = $display_settings['galleries_per_page'] * ($current_page - 1); 
  476.       $entities = $displayed_gallery->get_included_entities($display_settings['galleries_per_page'], $offset); 
  477.       // If there are entities to be displayed 
  478.       if ($entities) { 
  479.           $pagination_result = $this->object->create_pagination($current_page, $displayed_gallery->get_entity_count(), $display_settings['galleries_per_page'], urldecode($this->object->param('ajax_pagination_referrer'))); 
  480.           $display_settings['entities'] = $entities; 
  481.           $display_settings['pagination'] = $pagination_result['output']; 
  482.           $display_settings['displayed_gallery'] = $displayed_gallery; 
  483.           $display_settings = $this->prepare_legacy_album_params($displayed_gallery->get_entity(), $display_settings); 
  484.           if (!empty($display_settings['template']) && $display_settings['template'] != 'default') { 
  485.               // Add additional parameters 
  486.               $this->object->remove_param('ajax_pagination_referrer'); 
  487.               $display_settings['current_page'] = $current_page; 
  488.               $display_settings['pagination_prev'] = $pagination_result['prev']; 
  489.               $display_settings['pagination_next'] = $pagination_result['next']; 
  490.               // Legacy templates lack a good way of injecting content at the right time 
  491.               $this->object->add_mixin('Mixin_NextGen_Basic_Templates'); 
  492.               $this->object->add_mixin('A_NextGen_Album_Breadcrumbs'); 
  493.               $this->object->add_mixin('A_NextGen_Album_Descriptions'); 
  494.               $breadcrumbs = $this->object->render_legacy_template_breadcrumbs($displayed_gallery, $entities); 
  495.               $description = $this->object->render_legacy_template_description($displayed_gallery); 
  496.               // If enabled enqueue the child entities as JSON for lightboxes to read 
  497.               if (A_NextGen_Album_Child_Entities::are_child_entities_enabled($display_settings)) { 
  498.                   $script = A_NextGen_Album_Child_Entities::generate_script($entities); 
  499.               } 
  500.               $retval = $this->object->legacy_render($display_settings['template'], $display_settings, $return, 'album'); 
  501.               if (!empty($description)) { 
  502.                   $retval = $description . $retval; 
  503.               } 
  504.               if (!empty($breadcrumbs)) { 
  505.                   $retval = $breadcrumbs . $retval; 
  506.               } 
  507.               if (!empty($script)) { 
  508.                   $retval = $retval . $script; 
  509.               } 
  510.               return $retval; 
  511.           } else { 
  512.               $params = $display_settings; 
  513.               $params = $this->object->prepare_display_parameters($displayed_gallery, $params); 
  514.               switch ($displayed_gallery->display_type) { 
  515.                   case NGG_BASIC_COMPACT_ALBUM: 
  516.                       $template = 'compact'; 
  517.                       break; 
  518.                   case NGG_BASIC_EXTENDED_ALBUM: 
  519.                       $template = 'extended'; 
  520.                       break; 
  521.               } 
  522.               return $this->object->render_view("photocrati-nextgen_basic_album#{$template}", $params, $return); 
  523.           } 
  524.       } else { 
  525.           return $this->object->render_partial('photocrati-nextgen_gallery_display#no_images_found', array(), $return); 
  526.       } 
  527.   } 
  528.   /** 
  529.    * Creates a displayed gallery of a gallery belonging to an album. Shared by index_action() and cache_action() to 
  530.    * allow lightboxes to open album children directly. 
  531.    * 
  532.    * @param $gallery 
  533.    * @param $display_settings 
  534.    * @return $gallery 
  535.    */ 
  536.   function make_child_displayed_gallery($gallery, $display_settings) 
  537.   { 
  538.       $gallery->displayed_gallery = new C_Displayed_Gallery(); 
  539.       $gallery->displayed_gallery->container_ids = array($gallery->{$gallery->id_field}); 
  540.       $gallery->displayed_gallery->display_settings = $display_settings; 
  541.       $gallery->displayed_gallery->returns = 'included'; 
  542.       $gallery->displayed_gallery->source = 'galleries'; 
  543.       $gallery->displayed_gallery->images_list_count = $gallery->displayed_gallery->get_entity_count(); 
  544.       $gallery->displayed_gallery->is_album_gallery = TRUE; 
  545.       $gallery->displayed_gallery->to_transient(); 
  546.       return $gallery; 
  547.   } 
  548.   function add_breadcrumbs_to_legacy_templates($html, $displayed_gallery) 
  549.   { 
  550.       $this->object->add_mixin('A_NextGen_Album_Breadcrumbs'); 
  551.       $original_album_entities = array(); 
  552.       if (isset($displayed_gallery->display_settings['original_album_entities'])) { 
  553.           $original_album_entities = $displayed_gallery->display_settings['original_album_entities']; 
  554.       } elseif (isset($displayed_gallery->display_settings['original_settings']) && isset($displayed_gallery->display_settings['original_settings']['original_album_entities'])) { 
  555.           $original_album_entities = $displayed_gallery->display_settings['original_settings']['original_album_entities']; 
  556.       } 
  557.       $breadcrumbs = $this->object->render_legacy_template_breadcrumbs($displayed_gallery, $original_album_entities, $displayed_gallery->container_ids); 
  558.       if (!empty($breadcrumbs)) { 
  559.           $html = $breadcrumbs . $html; 
  560.       } 
  561.       return $html; 
  562.   } 
  563.   function add_description_to_legacy_templates($html, $displayed_gallery) 
  564.   { 
  565.       $this->object->add_mixin('A_NextGen_Album_Descriptions'); 
  566.       $description = $this->object->render_legacy_template_description($displayed_gallery); 
  567.       if (!empty($description)) { 
  568.           $html = $description . $html; 
  569.       } 
  570.       return $html; 
  571.   } 
  572.   /** 
  573.    * Gets the parent album for the entity being displayed 
  574.    * @param int $entity_id 
  575.    * @return stdClass (album) 
  576.    */ 
  577.   function get_parent_album_for($entity_id) 
  578.   { 
  579.       $retval = NULL; 
  580.       foreach ($this->albums as $album) { 
  581.           if (in_array($entity_id, $album->sortorder)) { 
  582.               $retval = $album; 
  583.               break; 
  584.           } 
  585.       } 
  586.       return $retval; 
  587.   } 
  588.   function prepare_legacy_album_params($displayed_gallery, $params) 
  589.   { 
  590.       $image_mapper = C_Image_Mapper::get_instance(); 
  591.       $storage = C_Gallery_Storage::get_instance(); 
  592.       $image_gen = C_Dynamic_Thumbnails_Manager::get_instance(); 
  593.       if (empty($displayed_gallery->display_settings['override_thumbnail_settings'])) { 
  594.           // legacy templates expect these dimensions 
  595.           $image_gen_params = array('width' => 91, 'height' => 68, 'crop' => TRUE); 
  596.       } else { 
  597.           // use settings requested by user 
  598.           $image_gen_params = array('width' => $displayed_gallery->display_settings['thumbnail_width'], 'height' => $displayed_gallery->display_settings['thumbnail_height'], 'quality' => isset($displayed_gallery->display_settings['thumbnail_quality']) ? $displayed_gallery->display_settings['thumbnail_quality'] : 100, 'crop' => isset($displayed_gallery->display_settings['thumbnail_crop']) ? $displayed_gallery->display_settings['thumbnail_crop'] : NULL, 'watermark' => isset($displayed_gallery->display_settings['thumbnail_watermark']) ? $displayed_gallery->display_settings['thumbnail_watermark'] : NULL); 
  599.       } 
  600.       // so user templates can know how big the images are expected to be 
  601.       $params['image_gen_params'] = $image_gen_params; 
  602.       // Transform entities 
  603.       $params['galleries'] = $params['entities']; 
  604.       unset($params['entities']); 
  605.       foreach ($params['galleries'] as &$gallery) { 
  606.           // Get the preview image url 
  607.           $gallery->previewurl = ''; 
  608.           if ($gallery->previewpic && $gallery->previewpic > 0) { 
  609.               if ($image = $image_mapper->find(intval($gallery->previewpic))) { 
  610.                   $gallery->previewpic_image = $image; 
  611.                   $gallery->previewpic_fullsized_url = $storage->get_image_url($image, 'full'); 
  612.                   $gallery->previewurl = $storage->get_image_url($image, $image_gen->get_size_name($image_gen_params), TRUE); 
  613.                   $gallery->previewname = $gallery->name; 
  614.               } 
  615.           } 
  616.           // Get the page link. If the entity is an album, then the url will 
  617.           // look like /nggallery/album--slug. 
  618.           $id_field = $gallery->id_field; 
  619.           if ($gallery->is_album) { 
  620.               if ($gallery->pageid > 0) { 
  621.                   $gallery->pagelink = @get_page_link($gallery->pageid); 
  622.               } else { 
  623.                   $pagelink = $this->object->get_routed_url(TRUE); 
  624.                   $pagelink = $this->object->remove_param_for($pagelink, 'album'); 
  625.                   $pagelink = $this->object->remove_param_for($pagelink, 'gallery'); 
  626.                   $pagelink = $this->object->remove_param_for($pagelink, 'nggpage'); 
  627.                   $pagelink = $this->object->set_param_for($pagelink, 'album', $gallery->slug); 
  628.                   $gallery->pagelink = $pagelink; 
  629.               } 
  630.           } else { 
  631.               if ($gallery->pageid > 0) { 
  632.                   $gallery->pagelink = @get_page_link($gallery->pageid); 
  633.               } 
  634.               if (empty($gallery->pagelink)) { 
  635.                   $pagelink = $this->object->get_routed_url(TRUE); 
  636.                   $parent_album = $this->object->get_parent_album_for($gallery->{$id_field}); 
  637.                   if ($parent_album) { 
  638.                       $pagelink = $this->object->remove_param_for($pagelink, 'album'); 
  639.                       $pagelink = $this->object->remove_param_for($pagelink, 'gallery'); 
  640.                       $pagelink = $this->object->remove_param_for($pagelink, 'nggpage'); 
  641.                       $pagelink = $this->object->set_param_for($pagelink, 'album', $parent_album->slug); 
  642.                   } else { 
  643.                       if ($displayed_gallery->container_ids === array('0') || $displayed_gallery->container_ids === array('')) { 
  644.                           $pagelink = $this->object->set_param_for($pagelink, 'album', 'all'); 
  645.                       } else { 
  646.                           $pagelink = $this->object->remove_param_for($pagelink, 'nggpage'); 
  647.                           $pagelink = $this->object->set_param_for($pagelink, 'album', 'album'); 
  648.                       } 
  649.                   } 
  650.                   $gallery->pagelink = $this->object->set_param_for($pagelink, 'gallery', $gallery->slug); 
  651.               } 
  652.           } 
  653.           // Mark the child type 
  654.           $gallery->entity_type = isset($gallery->is_gallery) && intval($gallery->is_gallery) ? 'gallery' : 'album'; 
  655.           // If this setting is on we need to inject an effect code 
  656.           if (!empty($displayed_gallery->display_settings['open_gallery_in_lightbox']) && $gallery->entity_type == 'gallery') { 
  657.               $gallery = $this->object->make_child_displayed_gallery($gallery, $displayed_gallery->display_settings); 
  658.               if ($this->does_lightbox_support_displayed_gallery($displayed_gallery)) { 
  659.                   $gallery->displayed_gallery->effect_code = $this->object->get_effect_code($gallery->displayed_gallery); 
  660.               } 
  661.           } 
  662.           // Let plugins modify the gallery 
  663.           $gallery = apply_filters('ngg_album_galleryobject', $gallery); 
  664.       } 
  665.       $params['galleries'] = apply_filters('ngg_album_prepared_child_entity', $params['galleries'], $params['displayed_gallery']); 
  666.       $params['album'] = reset($this->albums); 
  667.       $params['albums'] = $this->albums; 
  668.       // Clean up 
  669.       unset($storage); 
  670.       unset($image_mapper); 
  671.       unset($image_gen); 
  672.       unset($image_gen_params); 
  673.       return $params; 
  674.   } 
  675.   function _get_js_lib_url() 
  676.   { 
  677.       return $this->object->get_static_url('photocrati-nextgen_basic_album#init.js'); 
  678.   } 
  679.   /** 
  680.    * Enqueues all static resources required by this display type 
  681.    * 
  682.    * @param C_Displayed_Gallery $displayed_gallery 
  683.    */ 
  684.   function enqueue_frontend_resources($displayed_gallery) 
  685.   { 
  686.       $this->call_parent('enqueue_frontend_resources', $displayed_gallery); 
  687.       wp_enqueue_style('nextgen_basic_album_style', $this->object->get_static_url('photocrati-nextgen_basic_album#nextgen_basic_album.css'), FALSE, NGG_SCRIPT_VERSION); 
  688.       wp_enqueue_style('nextgen_pagination_style', $this->get_static_url('photocrati-nextgen_pagination#style.css'), FALSE, NGG_SCRIPT_VERSION); 
  689.       wp_enqueue_script('jquery.dotdotdot', $this->object->get_static_url('photocrati-nextgen_basic_album#jquery.dotdotdot-1.5.7-packed.js'), array('jquery'), NGG_SCRIPT_VERSION); 
  690.       $ds = $displayed_gallery->display_settings; 
  691.       if (!empty($ds['enable_breadcrumbs']) && $ds['enable_breadcrumbs'] || !empty($ds['original_settings']['enable_breadcrumbs']) && $ds['original_settings']['enable_breadcrumbs']) { 
  692.           wp_enqueue_style('nextgen_basic_album_breadcrumbs_style', $this->object->get_static_url('photocrati-nextgen_basic_album#breadcrumbs.css'), FALSE, NGG_SCRIPT_VERSION); 
  693.       } 
  694.       $this->enqueue_ngg_styles(); 
  695.   } 
  696. } 
  697. /** 
  698.  * Class A_NextGen_Basic_Album_Mapper 
  699.  * @mixin C_Display_Type_Mapper 
  700.  * @adapts I_Display_Type_Mapper 
  701.  */ 
  702. class A_NextGen_Basic_Album_Mapper extends Mixin 
  703. { 
  704.   function set_defaults($entity) 
  705.   { 
  706.       $this->call_parent('set_defaults', $entity); 
  707.       if (isset($entity->name) && in_array($entity->name, array(NGG_BASIC_COMPACT_ALBUM, NGG_BASIC_EXTENDED_ALBUM))) { 
  708.           // Set defaults for both display (album) types 
  709.           $settings = C_NextGen_Settings::get_instance(); 
  710.           $this->object->_set_default_value($entity, 'settings', 'galleries_per_page', $settings->galPagedGalleries); 
  711.           $this->object->_set_default_value($entity, 'settings', 'enable_breadcrumbs', 1); 
  712.           $this->object->_set_default_value($entity, 'settings', 'disable_pagination', 0); 
  713.           $this->object->_set_default_value($entity, 'settings', 'enable_descriptions', 0); 
  714.           $this->object->_set_default_value($entity, 'settings', 'template', ''); 
  715.           $this->object->_set_default_value($entity, 'settings', 'open_gallery_in_lightbox', 0); 
  716.           // Thumbnail dimensions -- only used by extended albums 
  717.           if ($entity->name == NGG_BASIC_EXTENDED_ALBUM) { 
  718.               $this->_set_default_value($entity, 'settings', 'override_thumbnail_settings', 0); 
  719.               $this->_set_default_value($entity, 'settings', 'thumbnail_width', $settings->thumbwidth); 
  720.               $this->_set_default_value($entity, 'settings', 'thumbnail_height', $settings->thumbheight); 
  721.               $this->_set_default_value($entity, 'settings', 'thumbnail_quality', $settings->thumbquality); 
  722.               $this->_set_default_value($entity, 'settings', 'thumbnail_crop', $settings->thumbfix); 
  723.               $this->_set_default_value($entity, 'settings', 'thumbnail_watermark', 0); 
  724.           } 
  725.           if (defined('NGG_BASIC_THUMBNAILS')) { 
  726.               $this->object->_set_default_value($entity, 'settings', 'gallery_display_type', NGG_BASIC_THUMBNAILS); 
  727.           } 
  728.           $this->object->_set_default_value($entity, 'settings', 'gallery_display_template', ''); 
  729.           $this->object->_set_default_value($entity, 'settings', 'ngg_triggers_display', 'never'); 
  730.       } 
  731.   } 
  732. } 
  733. /** 
  734.  * Class A_NextGen_Basic_Album_Routes 
  735.  * @mixin C_Displayed_Gallery_Renderer 
  736.  * @adapts I_Displayed_Gallery_Renderer 
  737.  */ 
  738. class A_NextGen_Basic_Album_Routes extends Mixin 
  739. { 
  740.   function render($displayed_gallery, $return = FALSE, $mode = NULL) 
  741.   { 
  742.       $do_rewrites = FALSE; 
  743.       $app = NULL; 
  744.       // Get display types 
  745.       $original_display_type = isset($displayed_gallery->display_settings['original_display_type']) ? $displayed_gallery->display_settings['original_display_type'] : ''; 
  746.       $display_type = $displayed_gallery->display_type; 
  747.       // If we're viewing an album, rewrite the urls 
  748.       $regex = "/photocrati-nextgen_basic_\\w+_album/"; 
  749.       if (preg_match($regex, $display_type)) { 
  750.           $do_rewrites = TRUE; 
  751.           // Get router 
  752.           $router = C_Router::get_instance(); 
  753.           $app = $router->get_routed_app(); 
  754.           $slug = '/' . C_NextGen_Settings::get_instance()->router_param_slug; 
  755.           $app->rewrite("{*}{$slug}/page/{\\d}{*}", "{1}{$slug}/nggpage--{2}{3}", FALSE, TRUE); 
  756.           $app->rewrite("{*}{$slug}/pid--{*}", "{1}{$slug}/pid--{2}", FALSE, TRUE); 
  757.           // avoid conflicts with imagebrowser 
  758.           $app->rewrite("{*}{$slug}/{\\w}/{\\w}/{\\w}{*}", "{1}{$slug}/album--{2}/gallery--{3}/{4}{5}", FALSE, TRUE); 
  759.           $app->rewrite("{*}{$slug}/{\\w}/{\\w}", "{1}{$slug}/album--{2}/gallery--{3}", FALSE, TRUE); 
  760.           // TODO: We're commenting this out as it was causing a problem with sub-album requests not 
  761.           // working when placed beside paginated galleries. But we still need to figure out why, and fix that 
  762.           // $app->rewrite("{*}{$slug}/{\\w}", "{1}{$slug}/album--{2}", FALSE, TRUE); 
  763.       } elseif (preg_match($regex, $original_display_type)) { 
  764.           $do_rewrites = TRUE; 
  765.           // Get router 
  766.           $router = C_Router::get_instance(); 
  767.           $app = $router->get_routed_app(); 
  768.           $slug = '/' . C_NextGen_Settings::get_instance()->router_param_slug; 
  769.           $app->rewrite("{*}{$slug}/album--{\\w}", "{1}{$slug}/{2}"); 
  770.           $app->rewrite("{*}{$slug}/album--{\\w}/gallery--{\\w}", "{1}{$slug}/{2}/{3}"); 
  771.           $app->rewrite("{*}{$slug}/album--{\\w}/gallery--{\\w}/{*}", "{1}{$slug}/{2}/{3}/{4}"); 
  772.       } 
  773.       // Perform rewrites 
  774.       if ($do_rewrites && $app) { 
  775.           $app->do_rewrites(); 
  776.       } 
  777.       return $this->call_parent('render', $displayed_gallery, $return, $mode); 
  778.   } 
  779. } 
  780. /** 
  781.  * Class A_NextGen_Basic_Album_Urls 
  782.  * @mixin C_Routing_App 
  783.  * @adapts I_Routing_App 
  784.  */ 
  785. class A_NextGen_Basic_Album_Urls extends Mixin 
  786. { 
  787.   function create_parameter_segment($key, $value, $id = NULL, $use_prefix = FALSE) 
  788.   { 
  789.       if ($key == 'nggpage') { 
  790.           return 'page/' . $value; 
  791.       } elseif ($key == 'album') { 
  792.           return $value; 
  793.       } elseif ($key == 'gallery') { 
  794.           return $value; 
  795.       } else { 
  796.           return $this->call_parent('create_parameter_segment', $key, $value, $id, $use_prefix); 
  797.       } 
  798.   } 
  799.   function remove_parameter($key, $id = NULL, $url = FALSE) 
  800.   { 
  801.       $retval = $this->call_parent('remove_parameter', $key, $id, $url); 
  802.       $settings = C_NextGen_Settings::get_instance(); 
  803.       $param_slug = preg_quote($settings->router_param_slug, '#'); 
  804.       if (preg_match("#(/{$param_slug}/.*)album--#", $retval, $matches)) { 
  805.           $retval = str_replace($matches[0], $matches[1], $retval); 
  806.       } 
  807.       if (preg_match("#(/{$param_slug}/.*)gallery--#", $retval, $matches)) { 
  808.           $retval = str_replace($matches[0], $matches[1], $retval); 
  809.       } 
  810.       return $retval; 
  811.   } 
  812. } 
  813. /** 
  814.  * Class Mixin_NextGen_Basic_Album_Form 
  815.  * @mixin C_Form 
  816.  */ 
  817. class Mixin_NextGen_Basic_Album_Form extends Mixin_Display_Type_Form 
  818. { 
  819.   function _get_field_names() 
  820.   { 
  821.       return array('nextgen_basic_album_gallery_display_type', 'nextgen_basic_album_galleries_per_page', 'nextgen_basic_album_enable_breadcrumbs', 'nextgen_basic_templates_template', 'nextgen_basic_album_enable_descriptions'); 
  822.   } 
  823.   /** 
  824.    * Renders the Gallery Display Type field 
  825.    * @param C_Display_Type $display_type 
  826.    */ 
  827.   function _render_nextgen_basic_album_gallery_display_type_field($display_type) 
  828.   { 
  829.       $mapper = C_Display_Type_Mapper::get_instance(); 
  830.       return $this->render_partial('photocrati-nextgen_basic_album#nextgen_basic_album_gallery_display_type', array('display_type_name' => $display_type->name, 'gallery_display_type_label' => __('Display galleries as', 'nggallery'), 'gallery_display_type_help' => __('How would you like galleries to be displayed?', 'nggallery'), 'gallery_display_type' => $display_type->settings['gallery_display_type'], 'galleries_per_page_label' => __('Galleries per page', 'nggallery'), 'galleries_per_page' => $display_type->settings['galleries_per_page'], 'display_types' => $mapper->find_by_entity_type('image')), TRUE); 
  831.   } 
  832.   /** 
  833.    * Renders the Galleries Per Page field 
  834.    * @param C_Display_Type $display_type 
  835.    */ 
  836.   function _render_nextgen_basic_album_galleries_per_page_field($display_type) 
  837.   { 
  838.       return $this->_render_number_field($display_type, 'galleries_per_page', __('Items per page', 'nggallery'), $display_type->settings['galleries_per_page'], __('Maximum number of galleries or sub-albums to appear on a single page', 'nggallery'), FALSE, '', 0); 
  839.   } 
  840.   function _render_nextgen_basic_album_enable_breadcrumbs_field($display_type) 
  841.   { 
  842.       return $this->_render_radio_field($display_type, 'enable_breadcrumbs', __('Enable breadcrumbs', 'nggallery'), isset($display_type->settings['enable_breadcrumbs']) ? $display_type->settings['enable_breadcrumbs'] : FALSE); 
  843.   } 
  844.   function _render_nextgen_basic_album_enable_descriptions_field($display_type) 
  845.   { 
  846.       return $this->_render_radio_field($display_type, 'enable_descriptions', __('Display descriptions', 'nggallery'), $display_type->settings['enable_descriptions']); 
  847.   } 
  848. } 
  849. /** 
  850.  * Class A_NextGen_Basic_Extended_Album_Form 
  851.  * @mixin C_Form 
  852.  * @adapts I_Form for the "photocrati-nextgen_basic_extended_album" context 
  853.  */ 
  854. class A_NextGen_Basic_Extended_Album_Form extends Mixin_NextGen_Basic_Album_Form 
  855. { 
  856.   function get_display_type_name() 
  857.   { 
  858.       return NGG_BASIC_EXTENDED_ALBUM; 
  859.   } 
  860.   /** 
  861.    * Returns a list of fields to render on the settings page 
  862.    */ 
  863.   function _get_field_names() 
  864.   { 
  865.       $fields = parent::_get_field_names(); 
  866.       $fields[] = 'thumbnail_override_settings'; 
  867.       return $fields; 
  868.   } 
  869.   /** 
  870.    * Enqueues static resources required by this form 
  871.    */ 
  872.   function enqueue_static_resources() 
  873.   { 
  874.       wp_enqueue_script('nextgen_basic_extended_albums_settings_script', $this->object->get_static_url('photocrati-nextgen_basic_album#extended_settings.js'), array('jquery.nextgen_radio_toggle'), NGG_SCRIPT_VERSION); 
  875.       $atp = C_Attach_Controller::get_instance(); 
  876.       if ($atp != null) { 
  877.           $atp->mark_script('nextgen_basic_extended_albums_settings_script'); 
  878.       } 
  879.   } 
  880. } 
  881. /** 
  882.  * Class A_NextGen_Basic_Compact_Album_Form 
  883.  * @mixin C_Form 
  884.  * @adapts I_Form for the "photocrati-nextgen_basic_compact_album" context 
  885.  */ 
  886. class A_NextGen_Basic_Compact_Album_Form extends Mixin_NextGen_Basic_Album_Form 
  887. { 
  888.   function get_display_type_name() 
  889.   { 
  890.       return NGG_BASIC_COMPACT_ALBUM; 
  891.   } 
  892.   /** 
  893.    * Returns a list of fields to render on the settings page 
  894.    */ 
  895.   function _get_field_names() 
  896.   { 
  897.       $fields = parent::_get_field_names(); 
  898.       $fields[] = 'thumbnail_override_settings'; 
  899.       return $fields; 
  900.   } 
  901.   /** 
  902.    * Enqueues static resources required by this form 
  903.    */ 
  904.   function enqueue_static_resources() 
  905.   { 
  906.       wp_enqueue_script('nextgen_basic_compact_albums_settings_script', $this->object->get_static_url('photocrati-nextgen_basic_album#compact_settings.js'), array('jquery.nextgen_radio_toggle'), NGG_SCRIPT_VERSION); 
  907.       $atp = C_Attach_Controller::get_instance(); 
  908.       if ($atp != null) { 
  909.           $atp->mark_script('nextgen_basic_compact_albums_settings_script'); 
  910.       } 
  911.   } 
  912. } 
.