PageRenderTime 64ms CodeModel.GetById 19ms RepoModel.GetById 1ms app.codeStats 0ms

/wp-content/plugins/file-gallery/includes/templating.php

https://bitbucket.org/antonyravel/cape-resorts
PHP | 1009 lines | 744 code | 199 blank | 66 comment | 223 complexity | 2c6a258163d4d5744c28a53fd79c0994 MD5 | raw file
    

  1. <?php

    2. 

  2. 

    3. 

  3. /**

    4. 

  4.  * Collects template names from theme folder

    5. 

  5.  */

    6. 

  6. function file_gallery_get_templates( $where = NULL )

    7. 

  7. {

    8. 

  8. 	$options = get_option('file_gallery');

    9. 

  9. 	

    10. 

  10. 	if( isset($options['cache']) && true == $options['cache'] )

    11. 

  11. 	{		

    12. 

  12. 		$transient = 'filegallery_templates';

    13. 

  13. 		$cache = get_transient($transient);

    14. 

  14. 		

    15. 

  15. 		if( $cache )

    16. 

  16. 			return $cache;

    17. 

  17. 	}

    18. 

  18. 

    19. 

  19. 	$file_gallery_templates = array();

    20. 

  20. 	

    21. 

  21. 	// check if file gallery templates folder exists within theme folder

    22. 

  22. 	if( is_readable(FILE_GALLERY_THEME_TEMPLATES_ABSPATH) )

    23. 

  23. 	{

    24. 

  24. 		$opendir = opendir(FILE_GALLERY_THEME_TEMPLATES_ABSPATH);

    25. 

  25. 		

    26. 

  26. 		while( false !== ($files = readdir($opendir)) )

    27. 

  27. 		{

    28. 

  28. 			if( '.' != $files && '..' != $files )

    29. 

  29. 			{

    30. 

  30. 				$tf = FILE_GALLERY_THEME_TEMPLATES_ABSPATH . '/' . $files;

    31. 

  31. 		

    32. 

  32. 				if( is_readable($tf . '/gallery.php') && is_readable($tf . '/gallery.css') )

    33. 

  33. 					$file_gallery_templates[] = $files;

    34. 

  34. 			}

    35. 

  35. 		}

    36. 

  36. 		

    37. 

  37. 		closedir($opendir);

    38. 

  38. 	}

    39. 

  39. 

    40. 

  40. 	// check if file gallery templates folder exists within wp-content/file-gallery-templates folder

    41. 

  41. 	if( is_readable(FILE_GALLERY_CONTENT_TEMPLATES_ABSPATH) )

    42. 

  42. 	{

    43. 

  43. 		$opendir = opendir(FILE_GALLERY_CONTENT_TEMPLATES_ABSPATH);

    44. 

  44. 		

    45. 

  45. 		while( false !== ($files = readdir($opendir)) )

    46. 

  46. 		{

    47. 

  47. 			if( '.' != $files && '..' != $files )

    48. 

  48. 			{

    49. 

  49. 				$tf = FILE_GALLERY_CONTENT_TEMPLATES_ABSPATH . '/' . $files;

    50. 

  50. 		

    51. 

  51. 				if( is_readable($tf . '/gallery.php') && is_readable($tf . '/gallery.css') )

    52. 

  52. 					$file_gallery_templates[] = $files;

    53. 

  53. 			}

    54. 

  54. 		}

    55. 

  55. 		

    56. 

  56. 		closedir($opendir);

    57. 

  57. 	}

    58. 

  58. 	

    59. 

  59. 	$file_gallery_templates = array_unique($file_gallery_templates);

    60. 

  60. 	

    61. 

  61. 	$default_templates = unserialize(FILE_GALLERY_DEFAULT_TEMPLATES);

    62. 

  62. 	

    63. 

  63. 	foreach( $default_templates as $df )

    64. 

  64. 	{

    65. 

  65. 		$file_gallery_templates[] = $df;

    66. 

  66. 	}

    67. 

  67. 	

    68. 

  68. 	if( isset($options['cache']) && true == $options['cache'] )

    69. 

  69. 		set_transient($transient, $file_gallery_templates, $options['cache_time']);

    70. 

  70. 

    71. 

  71. 	return $file_gallery_templates;

    72. 

  72. }

    73. 

  73. 

    74. 

  74. 

    75. 

  75. 

    76. 

  76. /**

    77. 

  77.  * Injects CSS links via 'stylesheet_uri' filter, if mobile theme is active

    78. 

  78.  */

    79. 

  79. function file_gallery_mobile_css( $stylesheet_url )

    80. 

  80. {

    81. 

  81. 	$options = get_option('file_gallery');

    82. 

  82. 	

    83. 

  83. 	if( isset($options['disable_shortcode_handler']) && true == $options['disable_shortcode_handler'] )

    84. 

  84. 		return $stylesheet_url;

    85. 

  85. 

    86. 

  86. 	file_gallery_css_front( true );

    87. 

  87. 	

    88. 

  88. 	$mobiles = maybe_unserialize(FILE_GALLERY_MOBILE_STYLESHEETS);

    89. 

  89. 

    90. 

  90. 	if( !empty($mobiles) )

    91. 

  91. 	{

    92. 

  92. 		array_push($mobiles, $stylesheet_url);

    93. 

  93. 		$glue = '" type="text/css" media="screen" charset="utf-8" />' . "\n\t" . '<link rel="stylesheet" href="';

    94. 

  94. 		return implode($glue, $mobiles);

    95. 

  95. 	}

    96. 

  96. 	

    97. 

  97. 	return $stylesheet_url;	

    98. 

  98. }

    99. 

  99. 

    100. 

  100. 

    101. 

  101. /**

    102. 

  102.  * Enqueues stylesheets for each gallery template

    103. 

  103.  */

    104. 

  104. function file_gallery_css_front( $mobile = false )

    105. 

  105. {

    106. 

  106. 	global $wp_query, $file_gallery;

    107. 

  107. 

    108. 

  108. 	$options = get_option('file_gallery');

    109. 

  109. 	

    110. 

  110. 	if( isset($options['disable_shortcode_handler']) && true == $options['disable_shortcode_handler'] )

    111. 

  111. 		return;

    112. 

  112. 

    113. 

  113. 	// if option to show galleries in excerpts is set to false

    114. 

  114. 	if( ! is_singular() && ( ! isset($options['in_excerpt']) || true != $options['in_excerpt']) && false == $mobile )

    115. 

  115. 		return;

    116. 

  116. 

    117. 

  117. 	$gallery_matches = 0;

    118. 

  118. 	$galleries = array();

    119. 

  119. 	$missing = array();

    120. 

  120. 	$mobiles = array();

    121. 

  121. 	$columns_required = false;

    122. 

  122. 	$default_templates = unserialize(FILE_GALLERY_DEFAULT_TEMPLATES);

    123. 

  123. 	

    124. 

  124. 	// check for gallery shortcode in all posts

    125. 

  125. 	if( ! empty($wp_query->posts) )

    126. 

  126. 	{

    127. 

  127. 		foreach( $wp_query->posts as $post )

    128. 

  128. 		{

    129. 

  129. 			$m = preg_match_all("#\[gallery([^\]]*)\]#is", $post->post_content, $g);

    130. 

  130. 

    131. 

  131. 			// if there's a match...

    132. 

  132. 			if( false !== $m && 0 < $m )

    133. 

  133. 			{

    134. 

  134. 				$gallery_matches += $m;    // ...add the number of matches to global count...

    135. 

  135. 				$galleries = array_merge($galleries, $g[1]); // ...and add the match to galleries array

    136. 

  136. 			}

    137. 

  137. 		}

    138. 

  138. 	}

    139. 

  139. 	

    140. 

  140. 	// no matches...

    141. 

  141. 	if( 0 === $gallery_matches )

    142. 

  142. 		return;

    143. 

  143. 	

    144. 

  144. 	// automaticaly enqueue predefined scripts and styles

    145. 

  145. 	$aqs = explode(',', $options['auto_enqueued_scripts']);

    146. 

  146. 	$aqs = array_map('trim', $aqs);

    147. 

  147. 	$aq_linkclasses = array();

    148. 

  148. 

    149. 

  149. 	// collect template names

    150. 

  150. 	foreach( $galleries as $gallery )

    151. 

  151. 	{

    152. 

  152. 		if( false === $columns_required )

    153. 

  153. 		{

    154. 

  154. 			$zc = preg_match("#\columns=(['\"])0\\1#is", $gallery);

    155. 

  155. 				

    156. 

  156. 			if( false !== $zc && 0 < $zc ) // no error and match found

    157. 

  157. 				$columns_required = false;

    158. 

  158. 			else

    159. 

  159. 				$columns_required = true;

    160. 

  160. 		}

    161. 

  161. 		

    162. 

  162. 		$tm = preg_match("#\stemplate=(['\"])([^'\"]+)\\1#is", $gallery, $gm);

    163. 

  163. 

    164. 

  164. 		if( isset($gm[2]) )

    165. 

  165. 			$templates[] = $gm[2];

    166. 

  166. 		

    167. 

  167. 		$gcm = preg_match("#\slinkclass=(['\"])([^'\"]+)\\1#is", $gallery, $gcg);

    168. 

  168. 

    169. 

  169. 		if( isset($gcg[2]) && '' != $gcg[2] )

    170. 

  170. 		{

    171. 

  171. 			$glc = explode(' ', $gcg[2]);

    172. 

  172. 

    173. 

  173. 			foreach( $glc as $glcs )

    174. 

  174. 			{

    175. 

  175. 				$glcs = trim($glcs);

    176. 

  176. 

    177. 

  177. 				if( in_array($glcs, $aqs) )//if( false !== strpos( implode(' ', $aqs), $glcs) )

    178. 

  178. 					$aq_linkclasses[] = $glcs;

    179. 

  179. 			}

    180. 

  180. 		}

    181. 

  181. 	}

    182. 

  182. 

    183. 

  183. 	$aq_linkclasses = apply_filters('file_gallery_lightbox_classes', array_unique($aq_linkclasses));

    184. 

  184. 

    185. 

  185. 	// auto enqueue scripts

    186. 

  186. 	if( ! empty($aq_linkclasses) )

    187. 

  187. 	{

    188. 

  188. 		if( ! defined('FILE_GALLERY_LIGHTBOX_CLASSES') )

    189. 

  189. 			define('FILE_GALLERY_LIGHTBOX_CLASSES', serialize($aq_linkclasses));

    190. 

  190. 

    191. 

  191. 		file_gallery_print_scripts( true );

    192. 

  192. 	}

    193. 

  193. 	

    194. 

  194. 	if( empty($templates) )

    195. 

  195. 	{

    196. 

  196. 		// enqueue only the default stylesheet if no template names are found

    197. 

  197. 		if( ! $mobile )

    198. 

  198. 			wp_enqueue_style('file_gallery_default', FILE_GALLERY_DEFAULT_TEMPLATE_URL . '/gallery.css', false, FILE_GALLERY_VERSION);

    199. 

  199. 		else

    200. 

  200. 			$mobiles[] = FILE_GALLERY_DEFAULT_TEMPLATE_URL . '/gallery.css';

    201. 

  201. 	}

    202. 

  202. 	else

    203. 

  203. 	{

    204. 

  204. 		if( count($templates) < count($galleries) )

    205. 

  205. 			$templates[] = 'default';

    206. 

  206. 

    207. 

  207. 		// eliminate duplicate entries

    208. 

  208. 		$templates = array_unique($templates);

    209. 

  209. 		

    210. 

  210. 		// if none of default templates are needed, don't include the 'columns.css' file

    211. 

  211. 		if( array() == array_intersect($templates, $default_templates) )

    212. 

  212. 			$columns_required = false;

    213. 

  213. 

    214. 

  214. 		// walk through template names

    215. 

  215. 		foreach($templates as $template)

    216. 

  216. 		{

    217. 

  217. 			$js_dependencies = isset($aq_linkclasses) ? $aq_linkclasses : array();

    218. 

  218. 

    219. 

  219. 			// check if file exists in theme's folder

    220. 

  220. 			if( is_readable(FILE_GALLERY_THEME_TEMPLATES_ABSPATH . '/' . $template . '/gallery.css') )

    221. 

  221. 			{

    222. 

  222. 				if( ! $mobile )

    223. 

  223. 					wp_enqueue_style('file_gallery_' . str_replace(' ', '-', $template), FILE_GALLERY_THEME_TEMPLATES_URL . '/' . str_replace(' ', '%20', $template) . '/gallery.css', false, FILE_GALLERY_VERSION);

    224. 

  224. 				else

    225. 

  225. 					$mobiles[] = FILE_GALLERY_THEME_TEMPLATES_URL . '/' . str_replace(' ', '%20', $template) . '/gallery.css';

    226. 

  226. 				

    227. 

  227. 				if( is_readable(FILE_GALLERY_THEME_TEMPLATES_ABSPATH . '/' . $template . '/gallery.js') )

    228. 

  228. 				{

    229. 

  229. 					$overriding = true;

    230. 

  230. 					ob_start();

    231. 

  231. 						include(FILE_GALLERY_THEME_TEMPLATES_ABSPATH . '/' . $template . '/gallery.php');					

    232. 

  232. 					ob_end_clean();

    233. 

  233. 					$overriding = false;

    234. 

  234. 

    235. 

  235. 					wp_enqueue_script('file_gallery_' . str_replace(' ', '-', $template), FILE_GALLERY_THEME_TEMPLATES_URL . '/' . str_replace(' ', '%20', $template) . '/gallery.js', $js_dependencies, FILE_GALLERY_VERSION, true);	

    236. 

  236. 				}

    237. 

  237. 			}

    238. 

  238. 			// check if file exists in wp-content/file-gallery-templates folder

    239. 

  239. 			elseif( is_readable(FILE_GALLERY_CONTENT_TEMPLATES_ABSPATH . '/' . $template . '/gallery.css') )

    240. 

  240. 			{

    241. 

  241. 				if( ! $mobile )

    242. 

  242. 					wp_enqueue_style('file_gallery_' . str_replace(' ', '-', $template), FILE_GALLERY_CONTENT_TEMPLATES_URL . '/' . str_replace(' ', '%20', $template) . '/gallery.css', false, FILE_GALLERY_VERSION);

    243. 

  243. 				else

    244. 

  244. 					$mobiles[] = FILE_GALLERY_CONTENT_TEMPLATES_URL . '/' . str_replace(' ', '%20', $template) . '/gallery.css';

    245. 

  245. 				

    246. 

  246. 				if( is_readable(FILE_GALLERY_CONTENT_TEMPLATES_ABSPATH . '/' . $template . '/gallery.js') )

    247. 

  247. 				{

    248. 

  248. 					$overriding = true;

    249. 

  249. 					ob_start();

    250. 

  250. 						include(FILE_GALLERY_CONTENT_TEMPLATES_ABSPATH . '/' . $template . '/gallery.php');					

    251. 

  251. 					ob_end_clean();

    252. 

  252. 					$overriding = false;

    253. 

  253. 

    254. 

  254. 					wp_enqueue_script('file_gallery_' . str_replace(' ', '-', $template), FILE_GALLERY_CONTENT_TEMPLATES_URL . '/' . str_replace(' ', '%20', $template) . '/gallery.js', $js_dependencies, FILE_GALLERY_VERSION, true);	

    255. 

  255. 				}

    256. 

  256. 			}

    257. 

  257. 			// check plugin templates folder

    258. 

  258. 			elseif( is_readable(FILE_GALLERY_ABSPATH . "/templates/" . $template . "/gallery.css") )

    259. 

  259. 			{				

    260. 

  260. 				if( ! $mobile )

    261. 

  261. 					wp_enqueue_style('file_gallery_' . $template, FILE_GALLERY_URL . '/templates/' . $template . '/gallery.css', false, FILE_GALLERY_VERSION);

    262. 

  262. 				else

    263. 

  263. 					$mobiles[] = FILE_GALLERY_URL . '/templates/' . $template . '/gallery.css';

    264. 

  264. 				

    265. 

  265. 				if( is_readable(FILE_GALLERY_ABSPATH . '/templates/' . $template . '/gallery.js') )

    266. 

  266. 				{

    267. 

  267. 					$overriding = true;

    268. 

  268. 					ob_start();

    269. 

  269. 						include(FILE_GALLERY_ABSPATH . '/templates/' . $template . '/gallery.php');

    270. 

  270. 					ob_end_clean();

    271. 

  271. 					$overriding = false;

    272. 

  272. 

    273. 

  273. 					wp_enqueue_script('file_gallery_' . str_replace(' ', '-', $template), FILE_GALLERY_URL . '/templates/' . str_replace(' ', '%20', $template) . '/gallery.js', $js_dependencies, FILE_GALLERY_VERSION, true );

    274. 

  274. 				}

    275. 

  275. 			}

    276. 

  276. 			// template does not exist, enqueue default one

    277. 

  277. 			else

    278. 

  278. 			{

    279. 

  279. 				$missing[] = $template;

    280. 

  280. 				wp_enqueue_style('file_gallery_default', FILE_GALLERY_URL . '/templates/default/gallery.css', false, FILE_GALLERY_VERSION);

    281. 

  281. 				

    282. 

  282. 				echo "\n<!-- " . __('file does not exist:', 'file-gallery') . ' ' . $template . '/gallery.css - ' . __('using default style', 'file-gallery') . "-->\n";

    283. 

  283. 			}

    284. 

  284. 		}

    285. 

  285. 	}

    286. 

  286. 	

    287. 

  287. 	if( $columns_required )

    288. 

  288. 	{

    289. 

  289. 		if( ! $mobile )

    290. 

  290. 			wp_enqueue_style('file_gallery_columns', FILE_GALLERY_URL . '/templates/columns.css', false, FILE_GALLERY_VERSION);

    291. 

  291. 		else

    292. 

  292. 			$mobiles[] = FILE_GALLERY_URL . '/templates/columns.css';

    293. 

  293. 	}

    294. 

  294. 

    295. 

  295. 	if( $mobile && ! defined('FILE_GALLERY_MOBILE_STYLESHEETS') )

    296. 

  296. 		define('FILE_GALLERY_MOBILE_STYLESHEETS', serialize($mobiles));

    297. 

  297. }

    298. 

  298. add_action('wp_print_styles',  'file_gallery_css_front');

    299. 

  299. add_action('wp_print_scripts', 'file_gallery_css_front');

    300. 

  300. 

    301. 

  301. 

    302. 

  302. /**

    303. 

  303.  * prints scripts and styles for auto enqueued linkclasses

    304. 

  304.  */

    305. 

  305. function file_gallery_print_scripts( $styles = false )

    306. 

  306. {

    307. 

  307. 	$options = get_option('file_gallery');

    308. 

  308. 	

    309. 

  309. 	if( isset($options['disable_shortcode_handler']) && true == $options['disable_shortcode_handler'] )

    310. 

  310. 		return;

    311. 

  311. 

    312. 

  312. 	if( defined('FILE_GALLERY_LIGHTBOX_CLASSES') )

    313. 

  313. 	{

    314. 

  314. 		$linkclasses = maybe_unserialize(FILE_GALLERY_LIGHTBOX_CLASSES);

    315. 

  315. 

    316. 

  316. 		if( ! empty($linkclasses) )

    317. 

  317. 		{

    318. 

  318. 			foreach( $linkclasses as $lc )

    319. 

  319. 			{

    320. 

  320. 				if( $styles )

    321. 

  321. 				{

    322. 

  322. 					wp_enqueue_style( $lc );

    323. 

  323. 				}

    324. 

  324. 				else

    325. 

  325. 				{

    326. 

  326. 					if( 'thickbox' == $lc )

    327. 

  327. 					{

    328. 

  328. echo "\n" . 

    329. 

  329. '<script type="text/javascript">

    330. 

  330. 	var tb_pathToImage = "' . includes_url() . 'js/thickbox/loadingAnimation.gif";

    331. 

  331. 	var tb_closeImage  = "' . includes_url() . 'js/thickbox/tb-close.png";

    332. 

  332. </script>'

    333. 

  333. . "\n";

    334. 

  334. 					}

    335. 

  335. 					

    336. 

  336. 					wp_enqueue_script( $lc );

    337. 

  337. 				}

    338. 

  338. 			}

    339. 

  339. 		}

    340. 

  340. 	}

    341. 

  341. }

    342. 

  342. add_action('wp_print_scripts', 'file_gallery_print_scripts');

    343. 

  343. 

    344. 

  344. 

    345. 

  345. /**

    346. 

  346.  * For easy inline overriding of shortcode-set options

    347. 

  347.  *

    348. 

  348.  * @since 1.6.5.1

    349. 

  349.  */

    350. 

  350. function file_gallery_overrides( $args )

    351. 

  351. {

    352. 

  352. 	global $file_gallery;

    353. 

  353. 

    354. 

  354. 	if( is_string($args) )

    355. 

  355. 		$args = wp_parse_args($args);

    356. 

  356. 	

    357. 

  357. 	$file_gallery->overrides = $args;

    358. 

  358. }

    359. 

  359. 

    360. 

  360. 

    361. 

  361. /**

    362. 

  362.  * Main shortcode function

    363. 

  363.  *

    364. 

  364.  * @since 0.1

    365. 

  365.  */

    366. 

  366. function file_gallery_shortcode( $content = false, $attr = false )

    367. 

  367. {

    368. 

  368. 	global $file_gallery, $wpdb, $post;

    369. 

  369. 

    370. 

  370. 	// if the function is called directly, not via shortcode

    371. 

  371. 	if( false !== $content && false === $attr )

    372. 

  372. 		$attr = wp_parse_args($content);

    373. 

  373. 		

    374. 

  374. 	if( ! isset($file_gallery->gallery_id) )

    375. 

  375. 		$file_gallery->gallery_id = 1;

    376. 

  376. 	else

    377. 

  377. 		$file_gallery->gallery_id++;

    378. 

  378. 	

    379. 

  379. 	$options = get_option('file_gallery');

    380. 

  380. 

    381. 

  381. 	if( isset($options['cache']) && true == $options['cache'] )

    382. 

  382. 	{

    383. 

  383. 		if( 'html' == $attr['output_type'] || ( isset($options['cache_non_html_output']) && true == $options['cache_non_html_output'] ) )

    384. 

  384. 		{

    385. 

  385. 			$transient = 'filegallery_' . md5( $post->ID . "_" . serialize($attr) );

    386. 

  386. 			$cache     = get_transient($transient);

    387. 

  387. 			

    388. 

  388. 			if( $cache )

    389. 

  389. 				return $cache;

    390. 

  390. 		}

    391. 

  391. 	}

    392. 

  392. 

    393. 

  393. 	// if option to show galleries in excerpts is set to false...

    394. 

  394. 	// ...replace [gallery] with user selected text

    395. 

  395. 	if( ! is_singular() && ( ! isset($options['in_excerpt']) || true != $options['in_excerpt']) )

    396. 

  396. 		return $options['in_excerpt_replace_content'];

    397. 

  397. 	

    398. 

  398. 	$default_templates = unserialize(FILE_GALLERY_DEFAULT_TEMPLATES);

    399. 

  399. 	

    400. 

  400. 	// We're trusting author input, so let's at least make sure it looks like a valid orderby statement

    401. 

  401. 	if( isset($attr['orderby']) )

    402. 

  402. 	{

    403. 

  403. 		$attr['orderby'] = sanitize_sql_orderby( $attr['orderby'] );

    404. 

  404. 		

    405. 

  405. 		if( ! $attr['orderby'] )

    406. 

  406. 			unset($attr['orderby']);

    407. 

  407. 	}

    408. 

  408. 	

    409. 

  409. 	$defaults = array(

    410. 

  410. 		/* default values: */

    411. 

  411. 		'order'				=> 'ASC',

    412. 

  412. 		'orderby'			=> '',

    413. 

  413. 		'id'				=> $post->ID,

    414. 

  414. 		'columns'			=> 3,

    415. 

  415. 		'size'				=> 'thumbnail',

    416. 

  416. 		'link'				=> 'attachment',

    417. 

  417. 		'include'			=> '',

    418. 

  418. 		'ids'				=> '',

    419. 

  419. 		'exclude'			=> '',

    420. 

  420. 

    421. 

  421. 		/* added by file gallery: */

    422. 

  422. 		'template'			=> 'default',

    423. 

  423. 		'linkclass'			=> '',

    424. 

  424. 		'imageclass'		=> '',

    425. 

  425. 		'galleryclass'		=> '',

    426. 

  426. 		'rel'				=> 1,

    427. 

  427. 		'tags'				=> '',

    428. 

  428. 		'tags_from'			=> 'current',

    429. 

  429. 		'output_type'		=> 'html',

    430. 

  430. 		'output_params'		=> 1,				// needed when outputting html

    431. 

  431. 		'attachment_ids'	=> '',				// old alias of 'include' and 'ids'

    432. 

  432. 		'mimetype'			=> '',

    433. 

  433. 		'limit' 			=> -1,

    434. 

  434. 		'offset'			=> -1,

    435. 

  435. 		'paginate'			=> 0,

    436. 

  436. 		'link_size'			=> 'full',

    437. 

  437. 		'include_meta'		=> false

    438. 

  438. 	);

    439. 

  439. 	

    440. 

  440. 	if( floatval(get_bloginfo('version')) >= 3.5 ) {

    441. 

  441. 		$defaults['link'] = 'post';

    442. 

  442. 	}

    443. 

  443. 	

    444. 

  444. 	// extract the defaults...

    445. 

  445. 	extract( shortcode_atts($defaults, $attr) );

    446. 

  446. 

    447. 

  447. 	if( ! in_array($template, $default_templates) )

    448. 

  448. 	{

    449. 

  449. 		$template_file = FILE_GALLERY_THEME_TEMPLATES_ABSPATH . '/' . $template . '/gallery.php';

    450. 

  450. 		

    451. 

  451. 		if( ! is_readable($template_file) )

    452. 

  452. 			$template_file = FILE_GALLERY_CONTENT_TEMPLATES_ABSPATH . '/' . $template . '/gallery.php';

    453. 

  453. 	}

    454. 

  454. 	else

    455. 

  455. 	{

    456. 

  456. 		if( 'default' == $template )

    457. 

  457. 		{

    458. 

  458. 			$template_file = FILE_GALLERY_DEFAULT_TEMPLATE_ABSPATH . '/gallery.php';

    459. 

  459. 			$template      = FILE_GALLERY_DEFAULT_TEMPLATE_NAME;

    460. 

  460. 		}

    461. 

  461. 		else

    462. 

  462. 		{

    463. 

  463. 			$template_file = FILE_GALLERY_ABSPATH . '/templates/' . $template . '/gallery.php';

    464. 

  464. 		}

    465. 

  465. 	}

    466. 

  466. 

    467. 

  467. 	// check if template exists and replace with default if it does not

    468. 

  468. 	if( ! is_readable($template_file) )

    469. 

  469. 	{

    470. 

  470. 		$template_file = FILE_GALLERY_ABSPATH . '/templates/default/gallery.php';

    471. 

  471. 		$template      = 'default';

    472. 

  472. 	}

    473. 

  473. 	

    474. 

  474. 	// get overriding variables from the template file

    475. 

  475. 	$overriding = true;

    476. 

  476. 	ob_start();

    477. 

  477. 		include($template_file);

    478. 

  478. 	ob_end_clean();

    479. 

  479. 	$overriding = false;

    480. 

  480. 

    481. 

  481. 	if( is_array($file_gallery->overrides) && ! empty($file_gallery->overrides) )

    482. 

  482. 	{

    483. 

  483. 		extract($file_gallery->overrides);

    484. 

  484. 		$file_gallery->overrides = NULL;

    485. 

  485. 	}

    486. 

  486. 

    487. 

  487. 	$limit  = (int) $limit;	

    488. 

  488. 	$offset = (int) $offset;

    489. 

  489. 	$page   = (int) get_query_var('page');

    490. 

  490. 

    491. 

  491. 	if( 'false' === $rel || (is_numeric($rel) && 0 === (int) $rel) )

    492. 

  492. 		$_rel = false;

    493. 

  493. 	elseif( 1 === $rel )

    494. 

  494. 		$_rel = true;

    495. 

  495. 	else

    496. 

  496. 		$_rel = $rel;

    497. 

  497. 

    498. 

  498. 	if( 'false' === $output_params || (is_numeric($output_params) && 0 === (int) $output_params) )

    499. 

  499. 		$output_params = false;

    500. 

  500. 	else

    501. 

  501. 		$output_params = true;

    502. 

  502. 	

    503. 

  503. 	if( 'false' === $paginate || (is_numeric($paginate) && 0 === (int) $paginate) || 0 > $limit )

    504. 

  504. 	{

    505. 

  505. 		$paginate   = false;

    506. 

  506. 		$found_rows = '';

    507. 

  507. 	}

    508. 

  508. 	else

    509. 

  509. 	{

    510. 

  510. 		$paginate   = true;

    511. 

  511. 		$found_rows = 'SQL_CALC_FOUND_ROWS';

    512. 

  512. 		

    513. 

  513. 		if( 0 === $page )

    514. 

  514. 			$page = 1;

    515. 

  515. 

    516. 

  516. 		if( is_singular() && 1 < $page )

    517. 

  517. 			$offset = $limit * ($page - 1);

    518. 

  518. 	}

    519. 

  519. 	

    520. 

  520. 	$file_gallery->debug_add('pagination', compact('paginate', 'page'));

    521. 

  521. 

    522. 

  522. /**/

    523. 

  523. 	$_attachment_ids = explode(',', trim($attachment_ids, ','));

    524. 

  524. 	$_include = explode(',', trim($include, ','));

    525. 

  525. 	$_ids = explode(',', trim($ids, ','));

    526. 

  526. 

    527. 

  527. 	$attachment_ids = array_merge($_attachment_ids, $_include, $_ids);

    528. 

  528. 	$attachment_ids = array_unique($attachment_ids);

    529. 

  529. 	$attachment_ids = implode(',', $attachment_ids);

    530. 

  530. 	$attachment_ids = trim($attachment_ids, ',');

    531. 

  531. 	$attachment_ids = trim($attachment_ids);

    532. 

  532. /**/

    533. 

  533. 

    534. 

  534. 	if( ! isset( $linkto ) )

    535. 

  535. 		$linkto = $link;

    536. 

  536. 	

    537. 

  537. 	$sql_mimetype = '';

    538. 

  538. 	

    539. 

  539. 	if( '' != $mimetype )

    540. 

  540. 	{

    541. 

  541. 		$mimetype     = file_gallery_get_mime_type($mimetype);

    542. 

  542. 		$sql_mimetype = wp_post_mime_type_where($mimetype);

    543. 

  543. 	}

    544. 

  544. 

    545. 

  545. 	$approved_attachment_post_statuses = apply_filters('file_gallery_approved_attachment_post_statuses', array('inherit'));

    546. 

  546. 	$ignored_attachment_post_statuses  = apply_filters('file_gallery_ignored_attachment_post_statuses', array('trash', 'private', 'pending', 'future'));

    547. 

  547. 	

    548. 

  548. 	if( ! empty($approved_attachment_post_statuses) )

    549. 

  549. 		$post_statuses = " AND (post_status IN ('" . implode("', '", $approved_attachment_post_statuses) . "') ) ";

    550. 

  550. 	elseif( ! empty($ignored_attachment_post_statuses) )

    551. 

  551. 		$post_statuses = " AND (post_status NOT IN ('" . implode("', '", $ignored_attachment_post_statuses) . "') ) ";

    552. 

  552. 	else

    553. 

  553. 		$post_statuses = "";

    554. 

  554. 	

    555. 

  555. 	$file_gallery_query = new stdClass();

    556. 

  556. 

    557. 

  557. 	// start with tags because they negate everything else

    558. 

  558. 	if( '' != $tags )

    559. 

  559. 	{

    560. 

  560. 		if( '' == $orderby || 'file_gallery' == $orderby )

    561. 

  561. 			$orderby = "menu_order ID";

    562. 

  562. 

    563. 

  563. 		$query = array(

    564. 

  564. 			'post_status'		=> implode(',', $approved_attachment_post_statuses), 

    565. 

  565. 			'post_type'			=> 'attachment', 

    566. 

  566. 			'order'				=> $order, 

    567. 

  567. 			'orderby'			=> $orderby,

    568. 

  568. 			'posts_per_page'	=> $limit,

    569. 

  569. 			'post_mime_type'	=> $mimetype,

    570. 

  570. 			FILE_GALLERY_MEDIA_TAG_NAME => $tags

    571. 

  571. 		);

    572. 

  572. 		

    573. 

  573. 		if( 'current' == $tags_from )

    574. 

  574. 			$query['post_parent'] = $id;

    575. 

  575. 		

    576. 

  576. 		if ( ! empty($exclude) )

    577. 

  577. 			$query['post__not_in'] = explode(',', preg_replace( '/[^0-9,]+/', '', $exclude ));

    578. 

  578. 		

    579. 

  579. 		if( 0 < $offset )

    580. 

  580. 			$query['offset'] = $offset;

    581. 

  581. 

    582. 

  582. 		$file_gallery_query = new WP_Query( $query );

    583. 

  583. 		$attachments = $file_gallery_query->posts;

    584. 

  584. 

    585. 

  585. 		unset($query);

    586. 

  586. 	}

    587. 

  587. 	elseif( '' != $attachment_ids )

    588. 

  588. 	{

    589. 

  589. 		$attachment_ids = explode(',', $attachment_ids);

    590. 

  590. 		$sql_limit = count($attachment_ids);

    591. 

  591. 

    592. 

  592. 		if( 'rand' == $orderby )

    593. 

  593. 			shuffle($attachment_ids);

    594. 

  594. 			

    595. 

  595. 		$attachment_ids = implode(',', $attachment_ids);

    596. 

  596. 

    597. 

  597. 		if( '' == $orderby || 'rand' == $orderby || $orderby == 'post__in' )

    598. 

  598. 		{

    599. 

  599. 			$orderby = sprintf("FIELD(ID, %s)", $attachment_ids);

    600. 

  600. 			$order   = '';

    601. 

  601. 		}

    602. 

  602. 		elseif( 'title' == $orderby )

    603. 

  603. 		{

    604. 

  604. 			$orderby = "post_title";

    605. 

  605. 		}

    606. 

  606. 		

    607. 

  607. 		$query = sprintf(

    608. 

  608. 			"SELECT " . $found_rows . " * FROM $wpdb->posts 

    609. 

  609. 			 WHERE ID IN (%s) 

    610. 

  610. 			 AND post_type = 'attachment' 

    611. 

  611. 			" . $post_statuses . " ", 

    612. 

  612. 		$attachment_ids);

    613. 

  613. 		

    614. 

  614. 		$query .= $sql_mimetype;

    615. 

  615. 		$query .= sprintf(" ORDER BY %s %s ", $orderby, $order);

    616. 

  616. 

    617. 

  617. 		if( true !== $paginate )

    618. 

  618. 			$limit = $sql_limit;

    619. 

  619. 	}

    620. 

  620. 	else

    621. 

  621. 	{

    622. 

  622. 		if( '' == $orderby )

    623. 

  623. 			$orderby = "menu_order ID";

    624. 

  624. 

    625. 

  625. 		$query = array(

    626. 

  626. 			'post_parent'		=> $id,

    627. 

  627. 			'post_status'		=> implode(',', $approved_attachment_post_statuses), 

    628. 

  628. 			'post_type'			=> 'attachment', 

    629. 

  629. 			'order'				=> $order, 

    630. 

  630. 			'orderby'			=> $orderby,

    631. 

  631. 			'posts_per_page'	=> $limit,

    632. 

  632. 			'post_mime_type'	=> $mimetype

    633. 

  633. 		);

    634. 

  634. 

    635. 

  635. 		if ( ! empty($exclude) )

    636. 

  636. 			$query['post__not_in'] = explode(',', preg_replace( '/[^0-9,]+/', '', $exclude ));

    637. 

  637. 		

    638. 

  638. 		if( 0 < $offset )

    639. 

  639. 			$query['offset'] = $offset;

    640. 

  640. 

    641. 

  641. 		$file_gallery_query = new WP_Query( $query );

    642. 

  642. 		$attachments = $file_gallery_query->posts;

    643. 

  643. 

    644. 

  644. 		unset($query);

    645. 

  645. 	}

    646. 

  646. 	

    647. 

  647. 	if( isset($query) )

    648. 

  648. 	{		

    649. 

  649. 		if( 0 < $limit )

    650. 

  650. 			$query .= " LIMIT " . $limit;

    651. 

  651. 		

    652. 

  652. 		if( 0 < $offset )

    653. 

  653. 			$query .= " OFFSET " . $offset;

    654. 

  654. 

    655. 

  655. 		$attachments = $wpdb->get_results( $query );

    656. 

  656. 

    657. 

  657. 		if( '' != $found_rows )

    658. 

  658. 		{

    659. 

  659. 			$file_gallery_query->found_posts = $wpdb->get_var("SELECT FOUND_ROWS()");

    660. 

  660. 			$file_gallery_query->max_num_pages = ceil($file_gallery_query->found_posts / $limit);

    661. 

  661. 		}

    662. 

  662. 	}

    663. 

  663. 

    664. 

  664. 	$file_gallery->debug_add('attachments_query', compact('file_gallery_query'));

    665. 

  665. 	

    666. 

  666. 	if( empty($attachments) )

    667. 

  667. 		return '<!-- "File Gallery" plugin says: - No attachments found for the following shortcode arguments: "' . json_encode($attr) . '" -->';

    668. 

  668. 

    669. 

  669. 	// feed

    670. 

  670. 	if( is_feed() )

    671. 

  671. 	{

    672. 

  672. 		$output = "\n";

    673. 

  673. 

    674. 

  674. 		foreach( $attachments as $attachment )

    675. 

  675. 		{

    676. 

  676. 			$output .= wp_get_attachment_link($attachment->ID, $size, true) . "\n";

    677. 

  677. 		}

    678. 

  678. 		

    679. 

  679. 		return $output;

    680. 

  680. 	}

    681. 

  681. 	

    682. 

  682. 	$i = 0;

    683. 

  683. 	$unique_ids = array();

    684. 

  684. 	$gallery_items = '';

    685. 

  685. 	

    686. 

  686. 	if( 'object' == $output_type || 'array' == $output_type )

    687. 

  687. 		$gallery_items = array();

    688. 

  688. 	

    689. 

  689. 	$autoqueueclasses = array();

    690. 

  690. 	

    691. 

  691. 	if( defined('FILE_GALLERY_LIGHTBOX_CLASSES') )

    692. 

  692. 		$autoqueueclasses = maybe_unserialize(FILE_GALLERY_LIGHTBOX_CLASSES);

    693. 

  693. 	else

    694. 

  694. 		$autoqueueclasses = explode(',', $options['auto_enqueued_scripts']);

    695. 

  695. 	

    696. 

  696. 	$file_gallery_this_template_counter = 1;

    697. 

  697. 

    698. 

  698. 	// create output

    699. 

  699. 	foreach($attachments as $attachment)

    700. 

  700. 	{

    701. 

  701. 		$param = array(

    702. 

  702. 			'image_class' => $imageclass,

    703. 

  703. 			'link_class'  => $linkclass,

    704. 

  704. 			'rel'         => $_rel,

    705. 

  705. 			'title'       => '',

    706. 

  706. 			'caption'     => '',

    707. 

  707. 			'description' => '',

    708. 

  708. 			'thumb_alt'   => ''

    709. 

  709. 		);

    710. 

  710. 

    711. 

  711. 		$attachment_file = get_attached_file($attachment->ID);

    712. 

  712. 		$attachment_is_image = file_gallery_file_is_displayable_image($attachment_file);

    713. 

  713. 		$startcol = '';

    714. 

  714. 		$endcol = '';

    715. 

  715. 		$x = '';

    716. 

  716. 

    717. 

  717. 		if( $output_params )

    718. 

  718. 		{			

    719. 

  719. 			$plcai = array_intersect($autoqueueclasses, explode(' ', trim($linkclass)));

    720. 

  720. 

    721. 

  721. 			if( ! empty($plcai) )

    722. 

  722. 			{

    723. 

  723. 				if( $attachment_is_image )

    724. 

  724. 				{

    725. 

  725. 					if( true === $param['rel'] )

    726. 

  726. 					{

    727. 

  727. 						$param['rel'] = $plcai[0] . '[' .  $file_gallery->gallery_id . ']';

    728. 

  728. 					}

    729. 

  729. 					elseif( ! is_bool($param['rel']) )

    730. 

  730. 					{

    731. 

  731. 						if( false !== strpos($_rel, '$GID$') )

    732. 

  732. 							$param['rel'] = str_replace('$GID$', $file_gallery->gallery_id, $_rel);

    733. 

  733. 						else

    734. 

  734. 							$param['rel'] = $_rel . '[' .  $file_gallery->gallery_id . ']';

    735. 

  735. 					}

    736. 

  736. 					

    737. 

  737. 					$filter_args = array(

    738. 

  738. 						'gallery_id' => $file_gallery->gallery_id, 

    739. 

  739. 						'linkrel'    => $param['rel'],

    740. 

  740. 						'linkclass'  => $param['link_class'],

    741. 

  741. 						'imageclass' => $param['image_class']

    742. 

  742. 					);

    743. 

  743. 

    744. 

  744. 					if( $param['rel'] )

    745. 

  745. 						$param['rel'] = apply_filters('file_gallery_lightbox_linkrel',    $param['rel'],         'linkrel',    $filter_args);

    746. 

  746. 					

    747. 

  747. 					$param['link_class']  = apply_filters('file_gallery_lightbox_linkclass',  $param['link_class'],  'linkclass',  $filter_args);

    748. 

  748. 					$param['image_class'] = apply_filters('file_gallery_lightbox_imageclass', $param['image_class'], 'imageclass', $filter_args);

    749. 

  749. 				}

    750. 

  750. 				else

    751. 

  751. 				{

    752. 

  752. 					$param['link_class'] = str_replace( trim(implode(' ', $plcai)), '', trim($linkclass));

    753. 

  753. 				}

    754. 

  754. 			}

    755. 

  755. 			

    756. 

  756. 			// if rel is still true or false

    757. 

  757. 			if( is_bool($param['rel']) )

    758. 

  758. 				$param['rel'] = '';

    759. 

  759. 

    760. 

  760. 			switch( $linkto )

    761. 

  761. 			{

    762. 

  762. 				case 'parent_post' :

    763. 

  763. 					$param['link'] = get_permalink( $wpdb->get_var("SELECT post_parent FROM $wpdb->posts WHERE ID = '" . $attachment->ID . "'") );

    764. 

  764. 					break;

    765. 

  765. 				case 'file' :

    766. 

  766. 					$param['link'] = wp_get_attachment_url($attachment->ID);

    767. 

  767. 					break;

    768. 

  768. 				case 'attachment' :

    769. 

  769. 				case 'post' :

    770. 

  770. 					$param['link'] = get_attachment_link($attachment->ID);

    771. 

  771. 					break;

    772. 

  772. 				case 'none' :

    773. 

  773. 					$param['link'] = '';

    774. 

  774. 					break;

    775. 

  775. 				default : // external url

    776. 

  776. 					$param['link'] = urldecode($linkto);

    777. 

  777. 					break;

    778. 

  778. 			}

    779. 

  779. 						

    780. 

  780. 			$param['title'] 		= $attachment->post_title;

    781. 

  781. 			$param['caption'] 		= $attachment->post_excerpt;

    782. 

  782. 			$param['description'] 	= $attachment->post_content;

    783. 

  783. 			

    784. 

  784. 			if( $attachment_is_image )

    785. 

  785. 			{

    786. 

  786. 				$thumb_src             = wp_get_attachment_image_src($attachment->ID, $size);

    787. 

  787. 				$param['thumb_link']   = $thumb_src[0];

    788. 

  788. 				$param['thumb_width']  = 0 == $thumb_src[1] ? file_gallery_get_image_size($param['thumb_link'])       : $thumb_src[1];

    789. 

  789. 				$param['thumb_height'] = 0 == $thumb_src[2] ? file_gallery_get_image_size($param['thumb_link'], true) : $thumb_src[2];	

    790. 

  790. 				

    791. 

  791. 				if( '' != $param['link'] && 'full' != $link_size && in_array($link_size, file_gallery_get_intermediate_image_sizes()) )

    792. 

  792. 				{

    793. 

  793. 					$full_src = wp_get_attachment_image_src($attachment->ID, $link_size);

    794. 

  794. 					$param['link'] = $full_src[0];

    795. 

  795. 				}

    796. 

  796. 			}

    797. 

  797. 			else

    798. 

  798. 			{

    799. 

  799. 				$param['thumb_link']   = wp_mime_type_icon($attachment->ID);

    800. 

  800. 				$param['thumb_link']   = apply_filters('file_gallery_non_image_thumb_link', $param['thumb_link'], $attachment->post_mime_type, $attachment->ID);

    801. 

  801. 				$param['thumb_width']  = '46';

    802. 

  802. 				$param['thumb_height'] = '60';

    803. 

  803. 			}

    804. 

  804. 

    805. 

  805. 			if( $thumb_alt = get_post_meta($attachment->ID, '_wp_attachment_image_alt', true) )

    806. 

  806. 				$param['thumb_alt'] = $thumb_alt;

    807. 

  807. 			

    808. 

  808. 			$param['attachment_id'] = $attachment->ID;

    809. 

  809. 		}

    810. 

  810. 		

    811. 

  811. 		$param = array_map('trim', $param);

    812. 

  812. 		

    813. 

  813. 		if( $include_meta )

    814. 

  814. 			$meta = get_post_custom($attachment->ID);

    815. 

  815. 		

    816. 

  816. 		if( 'object' == $output_type )

    817. 

  817. 		{

    818. 

  818. 			if( $output_params )

    819. 

  819. 				$attachment->params = (object) $param;

    820. 

  820. 			

    821. 

  821. 			if( $include_meta )

    822. 

  822. 				$attachment->meta = (object) $meta;

    823. 

  823. 

    824. 

  824. 			$gallery_items[] = $attachment;

    825. 

  825. 		}

    826. 

  826. 		elseif( 'array' == $output_type || 'json' == $output_type)

    827. 

  827. 		{

    828. 

  828. 			if( $output_params )

    829. 

  829. 				$attachment->params = $param;

    830. 

  830. 			

    831. 

  831. 			if( $include_meta )

    832. 

  832. 				$attachment->meta = $meta;

    833. 

  833. 			

    834. 

  834. 			$gallery_items[] = get_object_vars($attachment);

    835. 

  835. 		}

    836. 

  836. 		else

    837. 

  837. 		{

    838. 

  838. 			if( $columns > 0 )

    839. 

  839. 			{

    840. 

  840. 				if( 0 === $i || 0 === $i % $columns )

    841. 

  841. 					$startcol = ' gallery-startcol';

    842. 

  842. 				elseif( ($i+1) % $columns == 0 )// add the column break class

    843. 

  843. 					$endcol = ' gallery-endcol';

    844. 

  844. 			}

    845. 

  845. 

    846. 

  846. 			// parse template

    847. 

  847. 			ob_start();

    848. 

  848. 				extract( $param );

    849. 

  849. 				include($template_file);

    850. 

  850. 				$x = ob_get_contents();

    851. 

  851. 			ob_end_clean();

    852. 

  852. 			

    853. 

  853. 			$file_gallery_this_template_counter++;

    854. 

  854. 			

    855. 

  855. 			if ( $columns > 0 && $i+1 % $columns == 0 )

    856. 

  856. 				$x .= $cleartag;

    857. 

  857. 			

    858. 

  858. 			$gallery_items .= $x;

    859. 

  859. 			

    860. 

  860. 			$i++;

    861. 

  861. 		}

    862. 

  862. 	}

    863. 

  863. 

    864. 

  864. 	// handle data types

    865. 

  865. 	if( 'object' == $output_type || 'array' == $output_type )

    866. 

  866. 	{

    867. 

  867. 		$output = $gallery_items;

    868. 

  868. 	}

    869. 

  869. 	elseif( 'json' == $output_type )

    870. 

  870. 	{

    871. 

  871. 		$output = json_encode($gallery_items);

    872. 

  872. 	}

    873. 

  873. 	else

    874. 

  874. 	{

    875. 

  875. 		$stc = '';

    876. 

  876. 		$cols = '';

    877. 

  877. 		$pagination_html = '';

    878. 

  878. 

    879. 

  879. 		if( 0 < (int) $columns )

    880. 

  880. 			$cols = ' columns_' . $columns;

    881. 

  881. 		

    882. 

  882. 		if( isset($starttag_class) && '' != $starttag_class )

    883. 

  883. 			$stc = ' ' . $starttag_class;

    884. 

  884. 		

    885. 

  885. 		$trans_append = "\n<!-- file gallery output cached on " . date('Y.m.d @ H:i:s', time()) . "-->\n";

    886. 

  886. 		

    887. 

  887. 		if( is_singular() && isset($file_gallery_query->max_num_pages) && 1 < $file_gallery_query->max_num_pages )

    888. 

  888. 			$pagination_html = file_gallery_do_pagination( $file_gallery_query->max_num_pages, $page );

    889. 

  889. 

    890. 

  890. 		$gallery_class = apply_filters('file_gallery_galleryclass', 'gallery ' . str_replace(' ', '-', $template) . $cols . $stc . ' ' . $galleryclass);

    891. 

  891. 		

    892. 

  892. 		$output = '<' . $starttag . ' id="gallery-' . $file_gallery->gallery_id . '" class="' . $gallery_class . '">' . "\n" . $gallery_items . "\n" . $pagination_html . "\n</" . $starttag . '>';

    893. 

  893. 	}

    894. 

  894. 	

    895. 

  895. 	if( isset($options['cache']) && true == $options['cache'] )

    896. 

  896. 	{

    897. 

  897. 		if( 'html' == $output_type )

    898. 

  898. 			set_transient($transient, $output . $trans_append, $options['cache_time']); // with a comment appended to the end of cached output

    899. 

  899. 		elseif( isset($options['cache_non_html_output']) && true == $options['cache_non_html_output'] )

    900. 

  900. 			set_transient($transient, $output, $options['cache_time']);

    901. 

  901. 	}

    902. 

  902. 	

    903. 

  903. 	return apply_filters('file_gallery_output', $output, $post->ID, $file_gallery->gallery_id);

    904. 

  904. }

    905. 

  905. 

    906. 

  906. 

    907. 

  907. /**

    908. 

  908.  * Built-in pagination for galleries

    909. 

  909.  *

    910. 

  910.  * @since 1.6.5.1

    911. 

  911.  */

    912. 

  912. function file_gallery_do_pagination( $total = 0, $page = 0 )

    913. 

  913. {

    914. 

  914. 	if( 0 < $total && 0 < $page )

    915. 

  915. 	{

    916. 

  916. 		remove_query_arg('page');

    917. 

  917. 

    918. 

  918. 		$options = get_option('file_gallery');

    919. 

  919. 		$out = array('<span class="current">' . $page . '</span>');

    920. 

  920. 

    921. 

  921. 		if( ! isset($options['pagination_count']) || empty($options['pagination_count']) || 0 >= $options['pagination_count'] )

    922. 

  922. 			$limit = 9;

    923. 

  923. 		else

    924. 

  924. 			$limit = $options['pagination_count'];

    925. 

  925. 

    926. 

  926. 		$c = 0;

    927. 

  927. 		$l = $limit;

    928. 

  928. 		$end = false;

    929. 

  929. 		$start = false;

    930. 

  930. 		$current = $page;

    931. 

  931. 

    932. 

  932. 		$sides = ($limit - 1) / 2;

    933. 

  933. 		$sl = ceil($sides);

    934. 

  934. 		$sr = floor($sides);

    935. 

  935. 		

    936. 

  936. 		// skip to first page link

    937. 

  937. 		if( ($limit - $sl) < $current )

    938. 

  938. 			$start = true;

    939. 

  939. 		

    940. 

  940. 		// skip to last page link

    941. 

  941. 		if( ($total - $sr) > $current )

    942. 

  942. 			$end = true;

    943. 

  943. 

    944. 

  944. 		// left side

    945. 

  945. 		if( 1 < $current )

    946. 

  946. 		{

    947. 

  947. 			$current--;

    948. 

  948. 

    949. 

  949. 			while( 0 < $current && 0 < $sl)

    950. 

  950. 			{

    951. 

  951. 				array_unshift($out, str_replace('<a ', '<a class="page"', _wp_link_page($current)) . $current . '</a>');

    952. 

  952. 				

    953. 

  953. 				$current--;

    954. 

  954. 				$sl--;

    955. 

  955. 				$limit--;

    956. 

  956. 			}

    957. 

  957. 			

    958. 

  958. 			$c = $current;

    959. 

  959. 		}

    960. 

  960. 

    961. 

  961. 		$current = $page + 1;

    962. 

  962. 		$sr += $sl;

    963. 

  963. 		

    964. 

  964. 		// right side

    965. 

  965. 		while( $current <= $total && 0 < $sr )

    966. 

  966. 		{

    967. 

  967. 			array_push($out, str_replace('<a ', '<a class="page"', _wp_link_page($current)) . $current . '</a>');

    968. 

  968. 			

    969. 

  969. 			$current++;

    970. 

  970. 			$sr--;

    971. 

  971. 			$limit--;

    972. 

  972. 		}

    973. 

  973. 		

    974. 

  974. 		// leftovers

    975. 

  975. 		while( 1 < $limit && 0 < $c )

    976. 

  976. 		{

    977. 

  977. 			array_unshift($out, str_replace('<a ', '<a class="page"', _wp_link_page($c)) . $c . '</a>');

    978. 

  978. 

    979. 

  979. 			$c--;

    980. 

  980. 			$limit--;

    981. 

  981. 		}

    982. 

  982. 		

    983. 

  983. 		if( $start )

    984. 

  984. 			array_unshift($out, str_replace('<a ', '<a title="' . __('Skip to first page', 'file-gallery') . '" class="page"', _wp_link_page(1)) . '&laquo;</a>');

    985. 

  985. 		

    986. 

  986. 		if( $end )

    987. 

  987. 			array_push($out, str_replace('<a ', '<a title="' . __('Skip to last page', 'file-gallery') . '" class="page"', _wp_link_page($total)) . '&raquo;</a>');

    988. 

  988. 		

    989. 

  989. 		if( 'rtl' == get_bloginfo('text_direction') )

    990. 

  990. 			$out = array_reverse($out);

    991. 

  991. 		

    992. 

  992. 		return '<div class="wp-pagenavi">' . "\n" . implode("\n", $out) . "\n</div>";

    993. 

  993. 	}

    994. 

  994. 	

    995. 

  995. 	return '';

    996. 

  996. }

    997. 

  997. 

    998. 

  998. 

    999. 

  999. function file_gallery_register_shortcode_handler()

    1000. 

  1000. {

    1001. 

  1001. 	$options = get_option('file_gallery');

    1002. 

  1002. 

    1003. 

  1003. 	if( isset($options['disable_shortcode_handler']) && true == $options['disable_shortcode_handler'] )

    1004. 

  1004. 		return;

    1005. 

  1005. 

    1006. 

  1006. 	add_filter('post_gallery', 'file_gallery_shortcode', 10, 2);

    1007. 

  1007. }

    1008. 

  1008. add_action('init', 'file_gallery_register_shortcode_handler');

    1009. 

  1009. 

    1010. 

  1010.