PageRenderTime 58ms CodeModel.GetById 25ms RepoModel.GetById 0ms app.codeStats 0ms

/wp-includes/category-template.php

https://bitbucket.org/Thane2376/death-edge.ru
PHP | 1407 lines | 590 code | 149 blank | 668 comment | 162 complexity | 690123600ca9625eed3d80236e3d70de MD5 | raw file
Possible License(s): LGPL-2.1, GPL-2.0, LGPL-3.0, AGPL-1.0 
    

  1. <?php

    2. 

  2. /**

    3. 

  3.  * Category Template Tags and API.

    4. 

  4.  *

    5. 

  5.  * @package WordPress

    6. 

  6.  * @subpackage Template

    7. 

  7.  */

    8. 

  8. 

    9. 

  9. /**

    10. 

  10.  * Retrieve category link URL.

    11. 

  11.  *

    12. 

  12.  * @since 1.0.0

    13. 

  13.  * @see get_term_link()

    14. 

  14.  *

    15. 

  15.  * @param int|object $category Category ID or object.

    16. 

  16.  * @return string Link on success, empty string if category does not exist.

    17. 

  17.  */

    18. 

  18. function get_category_link( $category ) {

    19. 

  19. 	if ( ! is_object( $category ) )

    20. 

  20. 		$category = (int) $category;

    21. 

  21. 

    22. 

  22. 	$category = get_term_link( $category, 'category' );

    23. 

  23. 

    24. 

  24. 	if ( is_wp_error( $category ) )

    25. 

  25. 		return '';

    26. 

  26. 

    27. 

  27. 	return $category;

    28. 

  28. }

    29. 

  29. 

    30. 

  30. /**

    31. 

  31.  * Retrieve category parents with separator.

    32. 

  32.  *

    33. 

  33.  * @since 1.2.0

    34. 

  34.  *

    35. 

  35.  * @param int $id Category ID.

    36. 

  36.  * @param bool $link Optional, default is false. Whether to format with link.

    37. 

  37.  * @param string $separator Optional, default is '/'. How to separate categories.

    38. 

  38.  * @param bool $nicename Optional, default is false. Whether to use nice name for display.

    39. 

  39.  * @param array $visited Optional. Already linked to categories to prevent duplicates.

    40. 

  40.  * @return string|WP_Error A list of category parents on success, WP_Error on failure.

    41. 

  41.  */

    42. 

  42. function get_category_parents( $id, $link = false, $separator = '/', $nicename = false, $visited = array() ) {

    43. 

  43. 	$chain = '';

    44. 

  44. 	$parent = get_term( $id, 'category' );

    45. 

  45. 	if ( is_wp_error( $parent ) )

    46. 

  46. 		return $parent;

    47. 

  47. 

    48. 

  48. 	if ( $nicename )

    49. 

  49. 		$name = $parent->slug;

    50. 

  50. 	else

    51. 

  51. 		$name = $parent->name;

    52. 

  52. 

    53. 

  53. 	if ( $parent->parent && ( $parent->parent != $parent->term_id ) && !in_array( $parent->parent, $visited ) ) {

    54. 

  54. 		$visited[] = $parent->parent;

    55. 

  55. 		$chain .= get_category_parents( $parent->parent, $link, $separator, $nicename, $visited );

    56. 

  56. 	}

    57. 

  57. 

    58. 

  58. 	if ( $link )

    59. 

  59. 		$chain .= '<a href="' . esc_url( get_category_link( $parent->term_id ) ) . '">'.$name.'</a>' . $separator;

    60. 

  60. 	else

    61. 

  61. 		$chain .= $name.$separator;

    62. 

  62. 	return $chain;

    63. 

  63. }

    64. 

  64. 

    65. 

  65. /**

    66. 

  66.  * Retrieve post categories.

    67. 

  67.  *

    68. 

  68.  * @since 0.71

    69. 

  69.  * @uses $post

    70. 

  70.  *

    71. 

  71.  * @param int $id Optional, default to current post ID. The post ID.

    72. 

  72.  * @return array

    73. 

  73.  */

    74. 

  74. function get_the_category( $id = false ) {

    75. 

  75. 	$categories = get_the_terms( $id, 'category' );

    76. 

  76. 	if ( ! $categories || is_wp_error( $categories ) )

    77. 

  77. 		$categories = array();

    78. 

  78. 

    79. 

  79. 	$categories = array_values( $categories );

    80. 

  80. 

    81. 

  81. 	foreach ( array_keys( $categories ) as $key ) {

    82. 

  82. 		_make_cat_compat( $categories[$key] );

    83. 

  83. 	}

    84. 

  84. 

    85. 

  85. 	/**

    86. 

  86. 	 * Filter the array of categories to return for a post.

    87. 

  87. 	 *

    88. 

  88. 	 * @since 3.1.0

    89. 

  89. 	 *

    90. 

  90. 	 * @param array $categories An array of categories to return for the post.

    91. 

  91. 	 */

    92. 

  92. 	return apply_filters( 'get_the_categories', $categories );

    93. 

  93. }

    94. 

  94. 

    95. 

  95. /**

    96. 

  96.  * Sort categories by name.

    97. 

  97.  *

    98. 

  98.  * Used by usort() as a callback, should not be used directly. Can actually be

    99. 

  99.  * used to sort any term object.

    100. 

  100.  *

    101. 

  101.  * @since 2.3.0

    102. 

  102.  * @access private

    103. 

  103.  *

    104. 

  104.  * @param object $a

    105. 

  105.  * @param object $b

    106. 

  106.  * @return int

    107. 

  107.  */

    108. 

  108. function _usort_terms_by_name( $a, $b ) {

    109. 

  109. 	return strcmp( $a->name, $b->name );

    110. 

  110. }

    111. 

  111. 

    112. 

  112. /**

    113. 

  113.  * Sort categories by ID.

    114. 

  114.  *

    115. 

  115.  * Used by usort() as a callback, should not be used directly. Can actually be

    116. 

  116.  * used to sort any term object.

    117. 

  117.  *

    118. 

  118.  * @since 2.3.0

    119. 

  119.  * @access private

    120. 

  120.  *

    121. 

  121.  * @param object $a

    122. 

  122.  * @param object $b

    123. 

  123.  * @return int

    124. 

  124.  */

    125. 

  125. function _usort_terms_by_ID( $a, $b ) {

    126. 

  126. 	if ( $a->term_id > $b->term_id )

    127. 

  127. 		return 1;

    128. 

  128. 	elseif ( $a->term_id < $b->term_id )

    129. 

  129. 		return -1;

    130. 

  130. 	else

    131. 

  131. 		return 0;

    132. 

  132. }

    133. 

  133. 

    134. 

  134. /**

    135. 

  135.  * Retrieve category name based on category ID.

    136. 

  136.  *

    137. 

  137.  * @since 0.71

    138. 

  138.  *

    139. 

  139.  * @param int $cat_ID Category ID.

    140. 

  140.  * @return string|WP_Error Category name on success, WP_Error on failure.

    141. 

  141.  */

    142. 

  142. function get_the_category_by_ID( $cat_ID ) {

    143. 

  143. 	$cat_ID = (int) $cat_ID;

    144. 

  144. 	$category = get_term( $cat_ID, 'category' );

    145. 

  145. 

    146. 

  146. 	if ( is_wp_error( $category ) )

    147. 

  147. 		return $category;

    148. 

  148. 

    149. 

  149. 	return ( $category ) ? $category->name : '';

    150. 

  150. }

    151. 

  151. 

    152. 

  152. /**

    153. 

  153.  * Retrieve category list in either HTML list or custom format.

    154. 

  154.  *

    155. 

  155.  * @since 1.5.1

    156. 

  156.  *

    157. 

  157.  * @param string $separator Optional, default is empty string. Separator for between the categories.

    158. 

  158.  * @param string $parents Optional. How to display the parents.

    159. 

  159.  * @param int $post_id Optional. Post ID to retrieve categories.

    160. 

  160.  * @return string

    161. 

  161.  */

    162. 

  162. function get_the_category_list( $separator = '', $parents='', $post_id = false ) {

    163. 

  163. 	global $wp_rewrite;

    164. 

  164. 	if ( ! is_object_in_taxonomy( get_post_type( $post_id ), 'category' ) ) {

    165. 

  165. 		/** This filter is documented in wp-includes/category-template.php */

    166. 

  166. 		return apply_filters( 'the_category', '', $separator, $parents );

    167. 

  167. 	}

    168. 

  168. 

    169. 

  169. 	$categories = get_the_category( $post_id );

    170. 

  170. 	if ( empty( $categories ) ) {

    171. 

  171. 		/** This filter is documented in wp-includes/category-template.php */

    172. 

  172. 		return apply_filters( 'the_category', __( 'Uncategorized' ), $separator, $parents );

    173. 

  173. 	}

    174. 

  174. 

    175. 

  175. 	$rel = ( is_object( $wp_rewrite ) && $wp_rewrite->using_permalinks() ) ? 'rel="category tag"' : 'rel="category"';

    176. 

  176. 

    177. 

  177. 	$thelist = '';

    178. 

  178. 	if ( '' == $separator ) {

    179. 

  179. 		$thelist .= '<ul class="post-categories">';

    180. 

  180. 		foreach ( $categories as $category ) {

    181. 

  181. 			$thelist .= "\n\t<li>";

    182. 

  182. 			switch ( strtolower( $parents ) ) {

    183. 

  183. 				case 'multiple':

    184. 

  184. 					if ( $category->parent )

    185. 

  185. 						$thelist .= get_category_parents( $category->parent, true, $separator );

    186. 

  186. 					$thelist .= '<a href="' . esc_url( get_category_link( $category->term_id ) ) . '" ' . $rel . '>' . $category->name.'</a></li>';

    187. 

  187. 					break;

    188. 

  188. 				case 'single':

    189. 

  189. 					$thelist .= '<a href="' . esc_url( get_category_link( $category->term_id ) ) . '"  ' . $rel . '>';

    190. 

  190. 					if ( $category->parent )

    191. 

  191. 						$thelist .= get_category_parents( $category->parent, false, $separator );

    192. 

  192. 					$thelist .= $category->name.'</a></li>';

    193. 

  193. 					break;

    194. 

  194. 				case '':

    195. 

  195. 				default:

    196. 

  196. 					$thelist .= '<a href="' . esc_url( get_category_link( $category->term_id ) ) . '" ' . $rel . '>' . $category->name.'</a></li>';

    197. 

  197. 			}

    198. 

  198. 		}

    199. 

  199. 		$thelist .= '</ul>';

    200. 

  200. 	} else {

    201. 

  201. 		$i = 0;

    202. 

  202. 		foreach ( $categories as $category ) {

    203. 

  203. 			if ( 0 < $i )

    204. 

  204. 				$thelist .= $separator;

    205. 

  205. 			switch ( strtolower( $parents ) ) {

    206. 

  206. 				case 'multiple':

    207. 

  207. 					if ( $category->parent )

    208. 

  208. 						$thelist .= get_category_parents( $category->parent, true, $separator );

    209. 

  209. 					$thelist .= '<a href="' . esc_url( get_category_link( $category->term_id ) ) . '" ' . $rel . '>' . $category->name.'</a>';

    210. 

  210. 					break;

    211. 

  211. 				case 'single':

    212. 

  212. 					$thelist .= '<a href="' . esc_url( get_category_link( $category->term_id ) ) . '" ' . $rel . '>';

    213. 

  213. 					if ( $category->parent )

    214. 

  214. 						$thelist .= get_category_parents( $category->parent, false, $separator );

    215. 

  215. 					$thelist .= "$category->name</a>";

    216. 

  216. 					break;

    217. 

  217. 				case '':

    218. 

  218. 				default:

    219. 

  219. 					$thelist .= '<a href="' . esc_url( get_category_link( $category->term_id ) ) . '" ' . $rel . '>' . $category->name.'</a>';

    220. 

  220. 			}

    221. 

  221. 			++$i;

    222. 

  222. 		}

    223. 

  223. 	}

    224. 

  224. 

    225. 

  225. 	/**

    226. 

  226. 	 * Filter the category or list of categories.

    227. 

  227. 	 *

    228. 

  228. 	 * @since 1.2.0

    229. 

  229. 	 *

    230. 

  230. 	 * @param array  $thelist   List of categories for the current post.

    231. 

  231. 	 * @param string $separator Separator used between the categories.

    232. 

  232. 	 * @param string $parents   How to display the category parents. Accepts 'multiple',

    233. 

  233. 	 *                          'single', or empty.

    234. 

  234. 	 */

    235. 

  235. 	return apply_filters( 'the_category', $thelist, $separator, $parents );

    236. 

  236. }

    237. 

  237. 

    238. 

  238. /**

    239. 

  239.  * Check if the current post in within any of the given categories.

    240. 

  240.  *

    241. 

  241.  * The given categories are checked against the post's categories' term_ids, names and slugs.

    242. 

  242.  * Categories given as integers will only be checked against the post's categories' term_ids.

    243. 

  243.  *

    244. 

  244.  * Prior to v2.5 of WordPress, category names were not supported.

    245. 

  245.  * Prior to v2.7, category slugs were not supported.

    246. 

  246.  * Prior to v2.7, only one category could be compared: in_category( $single_category ).

    247. 

  247.  * Prior to v2.7, this function could only be used in the WordPress Loop.

    248. 

  248.  * As of 2.7, the function can be used anywhere if it is provided a post ID or post object.

    249. 

  249.  *

    250. 

  250.  * @since 1.2.0

    251. 

  251.  * @uses has_category()

    252. 

  252.  *

    253. 

  253.  * @param int|string|array $category Category ID, name or slug, or array of said.

    254. 

  254.  * @param int|object $post Optional. Post to check instead of the current post. (since 2.7.0)

    255. 

  255.  * @return bool True if the current post is in any of the given categories.

    256. 

  256.  */

    257. 

  257. function in_category( $category, $post = null ) {

    258. 

  258. 	if ( empty( $category ) )

    259. 

  259. 		return false;

    260. 

  260. 

    261. 

  261. 	return has_category( $category, $post );

    262. 

  262. }

    263. 

  263. 

    264. 

  264. /**

    265. 

  265.  * Display the category list for the post.

    266. 

  266.  *

    267. 

  267.  * @since 0.71

    268. 

  268.  *

    269. 

  269.  * @param string $separator Optional, default is empty string. Separator for between the categories.

    270. 

  270.  * @param string $parents Optional. How to display the parents.

    271. 

  271.  * @param int $post_id Optional. Post ID to retrieve categories.

    272. 

  272.  */

    273. 

  273. function the_category( $separator = '', $parents='', $post_id = false ) {

    274. 

  274. 	echo get_the_category_list( $separator, $parents, $post_id );

    275. 

  275. }

    276. 

  276. 

    277. 

  277. /**

    278. 

  278.  * Retrieve category description.

    279. 

  279.  *

    280. 

  280.  * @since 1.0.0

    281. 

  281.  *

    282. 

  282.  * @param int $category Optional. Category ID. Will use global category ID by default.

    283. 

  283.  * @return string Category description, available.

    284. 

  284.  */

    285. 

  285. function category_description( $category = 0 ) {

    286. 

  286. 	return term_description( $category, 'category' );

    287. 

  287. }

    288. 

  288. 

    289. 

  289. /**

    290. 

  290.  * Display or retrieve the HTML dropdown list of categories.

    291. 

  291.  *

    292. 

  292.  * The list of arguments is below:

    293. 

  293.  *     'show_option_all' (string) - Text to display for showing all categories.

    294. 

  294.  *     'show_option_none' (string) - Text to display for showing no categories.

    295. 

  295.  *     'option_none_value' (mixed) - Value to use when no category is selected.

    296. 

  296.  *     'orderby' (string) default is 'ID' - What column to use for ordering the

    297. 

  297.  * categories.

    298. 

  298.  *     'order' (string) default is 'ASC' - What direction to order categories.

    299. 

  299.  *     'show_count' (bool|int) default is 0 - Whether to show how many posts are

    300. 

  300.  * in the category.

    301. 

  301.  *     'hide_empty' (bool|int) default is 1 - Whether to hide categories that

    302. 

  302.  * don't have any posts attached to them.

    303. 

  303.  *     'child_of' (int) default is 0 - See {@link get_categories()}.

    304. 

  304.  *     'exclude' (string) - See {@link get_categories()}.

    305. 

  305.  *     'echo' (bool|int) default is 1 - Whether to display or retrieve content.

    306. 

  306.  *     'depth' (int) - The max depth.

    307. 

  307.  *     'tab_index' (int) - Tab index for select element.

    308. 

  308.  *     'name' (string) - The name attribute value for select element.

    309. 

  309.  *     'id' (string) - The ID attribute value for select element. Defaults to name if omitted.

    310. 

  310.  *     'class' (string) - The class attribute value for select element.

    311. 

  311.  *     'selected' (int) - Which category ID is selected.

    312. 

  312.  *     'taxonomy' (string) - The name of the taxonomy to retrieve. Defaults to category.

    313. 

  313.  *

    314. 

  314.  * The 'hierarchical' argument, which is disabled by default, will override the

    315. 

  315.  * depth argument, unless it is true. When the argument is false, it will

    316. 

  316.  * display all of the categories. When it is enabled it will use the value in

    317. 

  317.  * the 'depth' argument.

    318. 

  318.  *

    319. 

  319.  * @since 2.1.0

    320. 

  320.  *

    321. 

  321.  * @param string|array $args Optional. Override default arguments.

    322. 

  322.  * @return string HTML content only if 'echo' argument is 0.

    323. 

  323.  */

    324. 

  324. function wp_dropdown_categories( $args = '' ) {

    325. 

  325. 	$defaults = array(

    326. 

  326. 		'show_option_all' => '', 'show_option_none' => '',

    327. 

  327. 		'orderby' => 'id', 'order' => 'ASC',

    328. 

  328. 		'show_count' => 0,

    329. 

  329. 		'hide_empty' => 1, 'child_of' => 0,

    330. 

  330. 		'exclude' => '', 'echo' => 1,

    331. 

  331. 		'selected' => 0, 'hierarchical' => 0,

    332. 

  332. 		'name' => 'cat', 'id' => '',

    333. 

  333. 		'class' => 'postform', 'depth' => 0,

    334. 

  334. 		'tab_index' => 0, 'taxonomy' => 'category',

    335. 

  335. 		'hide_if_empty' => false, 'option_none_value' => -1

    336. 

  336. 	);

    337. 

  337. 

    338. 

  338. 	$defaults['selected'] = ( is_category() ) ? get_query_var( 'cat' ) : 0;

    339. 

  339. 

    340. 

  340. 	// Back compat.

    341. 

  341. 	if ( isset( $args['type'] ) && 'link' == $args['type'] ) {

    342. 

  342. 		_deprecated_argument( __FUNCTION__, '3.0', '' );

    343. 

  343. 		$args['taxonomy'] = 'link_category';

    344. 

  344. 	}

    345. 

  345. 

    346. 

  346. 	$r = wp_parse_args( $args, $defaults );

    347. 

  347. 	$option_none_value = $r['option_none_value'];

    348. 

  348. 

    349. 

  349. 	if ( ! isset( $r['pad_counts'] ) && $r['show_count'] && $r['hierarchical'] ) {

    350. 

  350. 		$r['pad_counts'] = true;

    351. 

  351. 	}

    352. 

  352. 

    353. 

  353. 	$tab_index = $r['tab_index'];

    354. 

  354. 

    355. 

  355. 	$tab_index_attribute = '';

    356. 

  356. 	if ( (int) $tab_index > 0 ) {

    357. 

  357. 		$tab_index_attribute = " tabindex=\"$tab_index\"";

    358. 

  358. 	}

    359. 

  359. 	$categories = get_terms( $r['taxonomy'], $r );

    360. 

  360. 	$name = esc_attr( $r['name'] );

    361. 

  361. 	$class = esc_attr( $r['class'] );

    362. 

  362. 	$id = $r['id'] ? esc_attr( $r['id'] ) : $name;

    363. 

  363. 

    364. 

  364. 	if ( ! $r['hide_if_empty'] || ! empty( $categories ) ) {

    365. 

  365. 		$output = "<select name='$name' id='$id' class='$class' $tab_index_attribute>\n";

    366. 

  366. 	} else {

    367. 

  367. 		$output = '';

    368. 

  368. 	}

    369. 

  369. 	if ( empty( $categories ) && ! $r['hide_if_empty'] && ! empty( $r['show_option_none'] ) ) {

    370. 

  370. 

    371. 

  371. 		/**

    372. 

  372. 		 * Filter a taxonomy drop-down display element.

    373. 

  373. 		 *

    374. 

  374. 		 * A variety of taxonomy drop-down display elements can be modified

    375. 

  375. 		 * just prior to display via this filter. Filterable arguments include

    376. 

  376. 		 * 'show_option_none', 'show_option_all', and various forms of the

    377. 

  377. 		 * term name.

    378. 

  378. 		 *

    379. 

  379. 		 * @since 1.2.0

    380. 

  380. 		 *

    381. 

  381. 		 * @see wp_dropdown_categories()

    382. 

  382. 		 *

    383. 

  383. 		 * @param string $element Taxonomy element to list.

    384. 

  384. 		 */

    385. 

  385. 		$show_option_none = apply_filters( 'list_cats', $r['show_option_none'] );

    386. 

  386. 		$output .= "\t<option value='" . esc_attr( $option_none_value ) . "' selected='selected'>$show_option_none</option>\n";

    387. 

  387. 	}

    388. 

  388. 

    389. 

  389. 	if ( ! empty( $categories ) ) {

    390. 

  390. 

    391. 

  391. 		if ( $r['show_option_all'] ) {

    392. 

  392. 

    393. 

  393. 			/** This filter is documented in wp-includes/category-template.php */

    394. 

  394. 			$show_option_all = apply_filters( 'list_cats', $r['show_option_all'] );

    395. 

  395. 			$selected = ( '0' === strval($r['selected']) ) ? " selected='selected'" : '';

    396. 

  396. 			$output .= "\t<option value='0'$selected>$show_option_all</option>\n";

    397. 

  397. 		}

    398. 

  398. 

    399. 

  399. 		if ( $r['show_option_none'] ) {

    400. 

  400. 

    401. 

  401. 			/** This filter is documented in wp-includes/category-template.php */

    402. 

  402. 			$show_option_none = apply_filters( 'list_cats', $r['show_option_none'] );

    403. 

  403. 			$selected = selected( $option_none_value, $r['selected'], false );

    404. 

  404. 			$output .= "\t<option value='" . esc_attr( $option_none_value ) . "'$selected>$show_option_none</option>\n";

    405. 

  405. 		}

    406. 

  406. 

    407. 

  407. 		if ( $r['hierarchical'] ) {

    408. 

  408. 			$depth = $r['depth'];  // Walk the full depth.

    409. 

  409. 		} else {

    410. 

  410. 			$depth = -1; // Flat.

    411. 

  411. 		}

    412. 

  412. 		$output .= walk_category_dropdown_tree( $categories, $depth, $r );

    413. 

  413. 	}

    414. 

  414. 

    415. 

  415. 	if ( ! $r['hide_if_empty'] || ! empty( $categories ) ) {

    416. 

  416. 		$output .= "</select>\n";

    417. 

  417. 	}

    418. 

  418. 	/**

    419. 

  419. 	 * Filter the taxonomy drop-down output.

    420. 

  420. 	 *

    421. 

  421. 	 * @since 2.1.0

    422. 

  422. 	 *

    423. 

  423. 	 * @param string $output HTML output.

    424. 

  424. 	 * @param array  $r      Arguments used to build the drop-down.

    425. 

  425. 	 */

    426. 

  426. 	$output = apply_filters( 'wp_dropdown_cats', $output, $r );

    427. 

  427. 

    428. 

  428. 	if ( $r['echo'] ) {

    429. 

  429. 		echo $output;

    430. 

  430. 	}

    431. 

  431. 	return $output;

    432. 

  432. }

    433. 

  433. 

    434. 

  434. /**

    435. 

  435.  * Display or retrieve the HTML list of categories.

    436. 

  436.  *

    437. 

  437.  * The list of arguments is below:

    438. 

  438.  *     'show_option_all' (string) - Text to display for showing all categories.

    439. 

  439.  *     'orderby' (string) default is 'ID' - What column to use for ordering the

    440. 

  440.  * categories.

    441. 

  441.  *     'order' (string) default is 'ASC' - What direction to order categories.

    442. 

  442.  *     'show_count' (bool|int) default is 0 - Whether to show how many posts are

    443. 

  443.  * in the category.

    444. 

  444.  *     'hide_empty' (bool|int) default is 1 - Whether to hide categories that

    445. 

  445.  * don't have any posts attached to them.

    446. 

  446.  *     'use_desc_for_title' (bool|int) default is 1 - Whether to use the

    447. 

  447.  * category description as the title attribute.

    448. 

  448.  *     'feed' - See {@link get_categories()}.

    449. 

  449.  *     'feed_type' - See {@link get_categories()}.

    450. 

  450.  *     'feed_image' - See {@link get_categories()}.

    451. 

  451.  *     'child_of' (int) default is 0 - See {@link get_categories()}.

    452. 

  452.  *     'exclude' (string) - See {@link get_categories()}.

    453. 

  453.  *     'exclude_tree' (string) - See {@link get_categories()}.

    454. 

  454.  *     'echo' (bool|int) default is 1 - Whether to display or retrieve content.

    455. 

  455.  *     'current_category' (int) - See {@link get_categories()}.

    456. 

  456.  *     'hierarchical' (bool) - See {@link get_categories()}.

    457. 

  457.  *     'title_li' (string) - See {@link get_categories()}.

    458. 

  458.  *     'depth' (int) - The max depth.

    459. 

  459.  *

    460. 

  460.  * @since 2.1.0

    461. 

  461.  *

    462. 

  462.  * @param string|array $args Optional. Override default arguments.

    463. 

  463.  * @return string HTML content only if 'echo' argument is 0.

    464. 

  464.  */

    465. 

  465. function wp_list_categories( $args = '' ) {

    466. 

  466. 	$defaults = array(

    467. 

  467. 		'show_option_all' => '', 'show_option_none' => __('No categories'),

    468. 

  468. 		'orderby' => 'name', 'order' => 'ASC',

    469. 

  469. 		'style' => 'list',

    470. 

  470. 		'show_count' => 0, 'hide_empty' => 1,

    471. 

  471. 		'use_desc_for_title' => 1, 'child_of' => 0,

    472. 

  472. 		'feed' => '', 'feed_type' => '',

    473. 

  473. 		'feed_image' => '', 'exclude' => '',

    474. 

  474. 		'exclude_tree' => '', 'current_category' => 0,

    475. 

  475. 		'hierarchical' => true, 'title_li' => __( 'Categories' ),

    476. 

  476. 		'echo' => 1, 'depth' => 0,

    477. 

  477. 		'taxonomy' => 'category'

    478. 

  478. 	);

    479. 

  479. 

    480. 

  480. 	$r = wp_parse_args( $args, $defaults );

    481. 

  481. 

    482. 

  482. 	if ( !isset( $r['pad_counts'] ) && $r['show_count'] && $r['hierarchical'] )

    483. 

  483. 		$r['pad_counts'] = true;

    484. 

  484. 

    485. 

  485. 	if ( true == $r['hierarchical'] ) {

    486. 

  486. 		$r['exclude_tree'] = $r['exclude'];

    487. 

  487. 		$r['exclude'] = '';

    488. 

  488. 	}

    489. 

  489. 

    490. 

  490. 	if ( ! isset( $r['class'] ) )

    491. 

  491. 		$r['class'] = ( 'category' == $r['taxonomy'] ) ? 'categories' : $r['taxonomy'];

    492. 

  492. 

    493. 

  493. 	if ( ! taxonomy_exists( $r['taxonomy'] ) ) {

    494. 

  494. 		return false;

    495. 

  495. 	}

    496. 

  496. 

    497. 

  497. 	$show_option_all = $r['show_option_all'];

    498. 

  498. 	$show_option_none = $r['show_option_none'];

    499. 

  499. 

    500. 

  500. 	$categories = get_categories( $r );

    501. 

  501. 

    502. 

  502. 	$output = '';

    503. 

  503. 	if ( $r['title_li'] && 'list' == $r['style'] ) {

    504. 

  504. 		$output = '<li class="' . esc_attr( $r['class'] ) . '">' . $r['title_li'] . '<ul>';

    505. 

  505. 	}

    506. 

  506. 	if ( empty( $categories ) ) {

    507. 

  507. 		if ( ! empty( $show_option_none ) ) {

    508. 

  508. 			if ( 'list' == $r['style'] ) {

    509. 

  509. 				$output .= '<li class="cat-item-none">' . $show_option_none . '</li>';

    510. 

  510. 			} else {

    511. 

  511. 				$output .= $show_option_none;

    512. 

  512. 			}

    513. 

  513. 		}

    514. 

  514. 	} else {

    515. 

  515. 		if ( ! empty( $show_option_all ) ) {

    516. 

  516. 			$posts_page = ( 'page' == get_option( 'show_on_front' ) && get_option( 'page_for_posts' ) ) ? get_permalink( get_option( 'page_for_posts' ) ) : home_url( '/' );

    517. 

  517. 			$posts_page = esc_url( $posts_page );

    518. 

  518. 			if ( 'list' == $r['style'] ) {

    519. 

  519. 				$output .= "<li class='cat-item-all'><a href='$posts_page'>$show_option_all</a></li>";

    520. 

  520. 			} else {

    521. 

  521. 				$output .= "<a href='$posts_page'>$show_option_all</a>";

    522. 

  522. 			}

    523. 

  523. 		}

    524. 

  524. 

    525. 

  525. 		if ( empty( $r['current_category'] ) && ( is_category() || is_tax() || is_tag() ) ) {

    526. 

  526. 			$current_term_object = get_queried_object();

    527. 

  527. 			if ( $current_term_object && $r['taxonomy'] === $current_term_object->taxonomy ) {

    528. 

  528. 				$r['current_category'] = get_queried_object_id();

    529. 

  529. 			}

    530. 

  530. 		}

    531. 

  531. 

    532. 

  532. 		if ( $r['hierarchical'] ) {

    533. 

  533. 			$depth = $r['depth'];

    534. 

  534. 		} else {

    535. 

  535. 			$depth = -1; // Flat.

    536. 

  536. 		}

    537. 

  537. 		$output .= walk_category_tree( $categories, $depth, $r );

    538. 

  538. 	}

    539. 

  539. 

    540. 

  540. 	if ( $r['title_li'] && 'list' == $r['style'] )

    541. 

  541. 		$output .= '</ul></li>';

    542. 

  542. 

    543. 

  543. 	/**

    544. 

  544. 	 * Filter the HTML output of a taxonomy list.

    545. 

  545. 	 *

    546. 

  546. 	 * @since 2.1.0

    547. 

  547. 	 *

    548. 

  548. 	 * @param string $output HTML output.

    549. 

  549. 	 * @param array  $args   An array of taxonomy-listing arguments.

    550. 

  550. 	 */

    551. 

  551. 	$html = apply_filters( 'wp_list_categories', $output, $args );

    552. 

  552. 

    553. 

  553. 	if ( $r['echo'] ) {

    554. 

  554. 		echo $html;

    555. 

  555. 	} else {

    556. 

  556. 		return $html;

    557. 

  557. 	}

    558. 

  558. }

    559. 

  559. 

    560. 

  560. /**

    561. 

  561.  * Display tag cloud.

    562. 

  562.  *

    563. 

  563.  * The text size is set by the 'smallest' and 'largest' arguments, which will

    564. 

  564.  * use the 'unit' argument value for the CSS text size unit. The 'format'

    565. 

  565.  * argument can be 'flat' (default), 'list', or 'array'. The flat value for the

    566. 

  566.  * 'format' argument will separate tags with spaces. The list value for the

    567. 

  567.  * 'format' argument will format the tags in a UL HTML list. The array value for

    568. 

  568.  * the 'format' argument will return in PHP array type format.

    569. 

  569.  *

    570. 

  570.  * The 'orderby' argument will accept 'name' or 'count' and defaults to 'name'.

    571. 

  571.  * The 'order' is the direction to sort, defaults to 'ASC' and can be 'DESC'.

    572. 

  572.  *

    573. 

  573.  * The 'number' argument is how many tags to return. By default, the limit will

    574. 

  574.  * be to return the top 45 tags in the tag cloud list.

    575. 

  575.  *

    576. 

  576.  * The 'topic_count_text' argument is a nooped plural from _n_noop() to generate the

    577. 

  577.  * text for the tooltip of the tag link.

    578. 

  578.  *

    579. 

  579.  * The 'topic_count_text_callback' argument is a function, which given the count

    580. 

  580.  * of the posts with that tag returns a text for the tooltip of the tag link.

    581. 

  581.  *

    582. 

  582.  * The 'post_type' argument is used only when 'link' is set to 'edit'. It determines the post_type

    583. 

  583.  * passed to edit.php for the popular tags edit links.

    584. 

  584.  *

    585. 

  585.  * The 'exclude' and 'include' arguments are used for the {@link get_tags()}

    586. 

  586.  * function. Only one should be used, because only one will be used and the

    587. 

  587.  * other ignored, if they are both set.

    588. 

  588.  *

    589. 

  589.  * @since 2.3.0

    590. 

  590.  *

    591. 

  591.  * @param array|string $args Optional. Override default arguments.

    592. 

  592.  * @return array Generated tag cloud, only if no failures and 'array' is set for the 'format' argument.

    593. 

  593.  */

    594. 

  594. function wp_tag_cloud( $args = '' ) {

    595. 

  595. 	$defaults = array(

    596. 

  596. 		'smallest' => 8, 'largest' => 22, 'unit' => 'pt', 'number' => 45,

    597. 

  597. 		'format' => 'flat', 'separator' => "\n", 'orderby' => 'name', 'order' => 'ASC',

    598. 

  598. 		'exclude' => '', 'include' => '', 'link' => 'view', 'taxonomy' => 'post_tag', 'post_type' => '', 'echo' => true

    599. 

  599. 	);

    600. 

  600. 	$args = wp_parse_args( $args, $defaults );

    601. 

  601. 

    602. 

  602. 	$tags = get_terms( $args['taxonomy'], array_merge( $args, array( 'orderby' => 'count', 'order' => 'DESC' ) ) ); // Always query top tags

    603. 

  603. 

    604. 

  604. 	if ( empty( $tags ) || is_wp_error( $tags ) )

    605. 

  605. 		return;

    606. 

  606. 

    607. 

  607. 	foreach ( $tags as $key => $tag ) {

    608. 

  608. 		if ( 'edit' == $args['link'] )

    609. 

  609. 			$link = get_edit_term_link( $tag->term_id, $tag->taxonomy, $args['post_type'] );

    610. 

  610. 		else

    611. 

  611. 			$link = get_term_link( intval($tag->term_id), $tag->taxonomy );

    612. 

  612. 		if ( is_wp_error( $link ) )

    613. 

  613. 			return false;

    614. 

  614. 

    615. 

  615. 		$tags[ $key ]->link = $link;

    616. 

  616. 		$tags[ $key ]->id = $tag->term_id;

    617. 

  617. 	}

    618. 

  618. 

    619. 

  619. 	$return = wp_generate_tag_cloud( $tags, $args ); // Here's where those top tags get sorted according to $args

    620. 

  620. 

    621. 

  621. 	/**

    622. 

  622. 	 * Filter the tag cloud output.

    623. 

  623. 	 *

    624. 

  624. 	 * @since 2.3.0

    625. 

  625. 	 *

    626. 

  626. 	 * @param string $return HTML output of the tag cloud.

    627. 

  627. 	 * @param array  $args   An array of tag cloud arguments.

    628. 

  628. 	 */

    629. 

  629. 	$return = apply_filters( 'wp_tag_cloud', $return, $args );

    630. 

  630. 

    631. 

  631. 	if ( 'array' == $args['format'] || empty($args['echo']) )

    632. 

  632. 		return $return;

    633. 

  633. 

    634. 

  634. 	echo $return;

    635. 

  635. }

    636. 

  636. 

    637. 

  637. /**

    638. 

  638.  * Default topic count scaling for tag links

    639. 

  639.  *

    640. 

  640.  * @param integer $count number of posts with that tag

    641. 

  641.  * @return integer scaled count

    642. 

  642.  */

    643. 

  643. function default_topic_count_scale( $count ) {

    644. 

  644. 	return round(log10($count + 1) * 100);

    645. 

  645. }

    646. 

  646. 

    647. 

  647. /**

    648. 

  648.  * Generates a tag cloud (heatmap) from provided data.

    649. 

  649.  *

    650. 

  650.  * The text size is set by the 'smallest' and 'largest' arguments, which will

    651. 

  651.  * use the 'unit' argument value for the CSS text size unit. The 'format'

    652. 

  652.  * argument can be 'flat' (default), 'list', or 'array'. The flat value for the

    653. 

  653.  * 'format' argument will separate tags with spaces. The list value for the

    654. 

  654.  * 'format' argument will format the tags in a UL HTML list. The array value for

    655. 

  655.  * the 'format' argument will return in PHP array type format.

    656. 

  656.  *

    657. 

  657.  * The 'tag_cloud_sort' filter allows you to override the sorting.

    658. 

  658.  * Passed to the filter: $tags array and $args array, has to return the $tags array

    659. 

  659.  * after sorting it.

    660. 

  660.  *

    661. 

  661.  * The 'orderby' argument will accept 'name' or 'count' and defaults to 'name'.

    662. 

  662.  * The 'order' is the direction to sort, defaults to 'ASC' and can be 'DESC' or

    663. 

  663.  * 'RAND'.

    664. 

  664.  *

    665. 

  665.  * The 'number' argument is how many tags to return. By default, the limit will

    666. 

  666.  * be to return the entire tag cloud list.

    667. 

  667.  *

    668. 

  668.  * The 'topic_count_text' argument is a nooped plural from _n_noop() to generate the

    669. 

  669.  * text for the tooltip of the tag link.

    670. 

  670.  *

    671. 

  671.  * The 'topic_count_text_callback' argument is a function, which given the count

    672. 

  672.  * of the posts with that tag returns a text for the tooltip of the tag link.

    673. 

  673.  *

    674. 

  674.  * @todo Complete functionality.

    675. 

  675.  * @since 2.3.0

    676. 

  676.  *

    677. 

  677.  * @param array $tags List of tags.

    678. 

  678.  * @param string|array $args Optional, override default arguments.

    679. 

  679.  * @return string|array Tag cloud as a string or an array, depending on 'format' argument.

    680. 

  680.  */

    681. 

  681. function wp_generate_tag_cloud( $tags, $args = '' ) {

    682. 

  682. 	$defaults = array(

    683. 

  683. 		'smallest' => 8, 'largest' => 22, 'unit' => 'pt', 'number' => 0,

    684. 

  684. 		'format' => 'flat', 'separator' => "\n", 'orderby' => 'name', 'order' => 'ASC',

    685. 

  685. 		'topic_count_text' => null, 'topic_count_text_callback' => null,

    686. 

  686. 		'topic_count_scale_callback' => 'default_topic_count_scale', 'filter' => 1,

    687. 

  687. 	);

    688. 

  688. 

    689. 

  689. 	$args = wp_parse_args( $args, $defaults );

    690. 

  690. 

    691. 

  691. 	$return = ( 'array' === $args['format'] ) ? array() : '';

    692. 

  692. 

    693. 

  693. 	if ( empty( $tags ) ) {

    694. 

  694. 		return $return;

    695. 

  695. 	}

    696. 

  696. 

    697. 

  697. 	// Juggle topic count tooltips:

    698. 

  698. 	if ( isset( $args['topic_count_text'] ) ) {

    699. 

  699. 		// First look for nooped plural support via topic_count_text.

    700. 

  700. 		$translate_nooped_plural = $args['topic_count_text'];

    701. 

  701. 	} elseif ( ! empty( $args['topic_count_text_callback'] ) ) {

    702. 

  702. 		// Look for the alternative callback style. Ignore the previous default.

    703. 

  703. 		if ( $args['topic_count_text_callback'] === 'default_topic_count_text' ) {

    704. 

  704. 			$translate_nooped_plural = _n_noop( '%s topic', '%s topics' );

    705. 

  705. 		} else {

    706. 

  706. 			$translate_nooped_plural = false;

    707. 

  707. 		}

    708. 

  708. 	} elseif ( isset( $args['single_text'] ) && isset( $args['multiple_text'] ) ) {

    709. 

  709. 		// If no callback exists, look for the old-style single_text and multiple_text arguments.

    710. 

  710. 		$translate_nooped_plural = _n_noop( $args['single_text'], $args['multiple_text'] );

    711. 

  711. 	} else {

    712. 

  712. 		// This is the default for when no callback, plural, or argument is passed in.

    713. 

  713. 		$translate_nooped_plural = _n_noop( '%s topic', '%s topics' );

    714. 

  714. 	}

    715. 

  715. 

    716. 

  716. 	/**

    717. 

  717. 	 * Filter how the items in a tag cloud are sorted.

    718. 

  718. 	 *

    719. 

  719. 	 * @since 2.8.0

    720. 

  720. 	 *

    721. 

  721. 	 * @param array $tags Ordered array of terms.

    722. 

  722. 	 * @param array $args An array of tag cloud arguments.

    723. 

  723. 	 */

    724. 

  724. 	$tags_sorted = apply_filters( 'tag_cloud_sort', $tags, $args );

    725. 

  725. 	if ( empty( $tags_sorted ) ) {

    726. 

  726. 		return $return;

    727. 

  727. 	}

    728. 

  728. 

    729. 

  729. 	if ( $tags_sorted !== $tags ) {

    730. 

  730. 		$tags = $tags_sorted;

    731. 

  731. 		unset( $tags_sorted );

    732. 

  732. 	} else {

    733. 

  733. 		if ( 'RAND' === $args['order'] ) {

    734. 

  734. 			shuffle( $tags );

    735. 

  735. 		} else {

    736. 

  736. 			// SQL cannot save you; this is a second (potentially different) sort on a subset of data.

    737. 

  737. 			if ( 'name' === $args['orderby'] ) {

    738. 

  738. 				uasort( $tags, '_wp_object_name_sort_cb' );

    739. 

  739. 			} else {

    740. 

  740. 				uasort( $tags, '_wp_object_count_sort_cb' );

    741. 

  741. 			}

    742. 

  742. 

    743. 

  743. 			if ( 'DESC' === $args['order'] ) {

    744. 

  744. 				$tags = array_reverse( $tags, true );

    745. 

  745. 			}

    746. 

  746. 		}

    747. 

  747. 	}

    748. 

  748. 

    749. 

  749. 	if ( $args['number'] > 0 )

    750. 

  750. 		$tags = array_slice( $tags, 0, $args['number'] );

    751. 

  751. 

    752. 

  752. 	$counts = array();

    753. 

  753. 	$real_counts = array(); // For the alt tag

    754. 

  754. 	foreach ( (array) $tags as $key => $tag ) {

    755. 

  755. 		$real_counts[ $key ] = $tag->count;

    756. 

  756. 		$counts[ $key ] = call_user_func( $args['topic_count_scale_callback'], $tag->count );

    757. 

  757. 	}

    758. 

  758. 

    759. 

  759. 	$min_count = min( $counts );

    760. 

  760. 	$spread = max( $counts ) - $min_count;

    761. 

  761. 	if ( $spread <= 0 )

    762. 

  762. 		$spread = 1;

    763. 

  763. 	$font_spread = $args['largest'] - $args['smallest'];

    764. 

  764. 	if ( $font_spread < 0 )

    765. 

  765. 		$font_spread = 1;

    766. 

  766. 	$font_step = $font_spread / $spread;

    767. 

  767. 

    768. 

  768. 	$a = array();

    769. 

  769. 

    770. 

  770. 	foreach ( $tags as $key => $tag ) {

    771. 

  771. 		$count = $counts[ $key ];

    772. 

  772. 		$real_count = $real_counts[ $key ];

    773. 

  773. 		$tag_link = '#' != $tag->link ? esc_url( $tag->link ) : '#';

    774. 

  774. 		$tag_id = isset($tags[ $key ]->id) ? $tags[ $key ]->id : $key;

    775. 

  775. 		$tag_name = $tags[ $key ]->name;

    776. 

  776. 

    777. 

  777. 		if ( $translate_nooped_plural ) {

    778. 

  778. 			$title_attribute = sprintf( translate_nooped_plural( $translate_nooped_plural, $real_count ), number_format_i18n( $real_count ) );

    779. 

  779. 		} else {

    780. 

  780. 			$title_attribute = call_user_func( $args['topic_count_text_callback'], $real_count, $tag, $args );

    781. 

  781. 		}

    782. 

  782. 

    783. 

  783. 		$a[] = "<a href='$tag_link' class='tag-link-$tag_id' title='" . esc_attr( $title_attribute ) . "' style='font-size: " .

    784. 

  784. 			str_replace( ',', '.', ( $args['smallest'] + ( ( $count - $min_count ) * $font_step ) ) )

    785. 

  785. 			. $args['unit'] . ";'>$tag_name</a>";

    786. 

  786. 	}

    787. 

  787. 

    788. 

  788. 	switch ( $args['format'] ) {

    789. 

  789. 		case 'array' :

    790. 

  790. 			$return =& $a;

    791. 

  791. 			break;

    792. 

  792. 		case 'list' :

    793. 

  793. 			$return = "<ul class='wp-tag-cloud'>\n\t<li>";

    794. 

  794. 			$return .= join( "</li>\n\t<li>", $a );

    795. 

  795. 			$return .= "</li>\n</ul>\n";

    796. 

  796. 			break;

    797. 

  797. 		default :

    798. 

  798. 			$return = join( $args['separator'], $a );

    799. 

  799. 			break;

    800. 

  800. 	}

    801. 

  801. 

    802. 

  802. 	if ( $args['filter'] ) {

    803. 

  803. 		/**

    804. 

  804. 		 * Filter the generated output of a tag cloud.

    805. 

  805. 		 *

    806. 

  806. 		 * The filter is only evaluated if a true value is passed

    807. 

  807. 		 * to the $filter argument in wp_generate_tag_cloud().

    808. 

  808. 		 *

    809. 

  809. 		 * @since 2.3.0

    810. 

  810. 		 *

    811. 

  811. 		 * @see wp_generate_tag_cloud()

    812. 

  812. 		 *

    813. 

  813. 		 * @param array|string $return String containing the generated HTML tag cloud output

    814. 

  814. 		 *                             or an array of tag links if the 'format' argument

    815. 

  815. 		 *                             equals 'array'.

    816. 

  816. 		 * @param array        $tags   An array of terms used in the tag cloud.

    817. 

  817. 		 * @param array        $args   An array of wp_generate_tag_cloud() arguments.

    818. 

  818. 		 */

    819. 

  819. 		return apply_filters( 'wp_generate_tag_cloud', $return, $tags, $args );

    820. 

  820. 	}

    821. 

  821. 

    822. 

  822. 	else

    823. 

  823. 		return $return;

    824. 

  824. }

    825. 

  825. 

    826. 

  826. /**

    827. 

  827.  * Callback for comparing objects based on name

    828. 

  828.  *

    829. 

  829.  * @since 3.1.0

    830. 

  830.  * @access private

    831. 

  831.  */

    832. 

  832. function _wp_object_name_sort_cb( $a, $b ) {

    833. 

  833. 	return strnatcasecmp( $a->name, $b->name );

    834. 

  834. }

    835. 

  835. 

    836. 

  836. /**

    837. 

  837.  * Callback for comparing objects based on count

    838. 

  838.  *

    839. 

  839.  * @since 3.1.0

    840. 

  840.  * @access private

    841. 

  841.  */

    842. 

  842. function _wp_object_count_sort_cb( $a, $b ) {

    843. 

  843. 	return ( $a->count > $b->count );

    844. 

  844. }

    845. 

  845. 

    846. 

  846. //

    847. 

  847. // Helper functions

    848. 

  848. //

    849. 

  849. 

    850. 

  850. /**

    851. 

  851.  * Retrieve HTML list content for category list.

    852. 

  852.  *

    853. 

  853.  * @uses Walker_Category to create HTML list content.

    854. 

  854.  * @since 2.1.0

    855. 

  855.  * @see Walker_Category::walk() for parameters and return description.

    856. 

  856.  */

    857. 

  857. function walk_category_tree() {

    858. 

  858. 	$args = func_get_args();

    859. 

  859. 	// the user's options are the third parameter

    860. 

  860. 	if ( empty($args[2]['walker']) || !is_a($args[2]['walker'], 'Walker') )

    861. 

  861. 		$walker = new Walker_Category;

    862. 

  862. 	else

    863. 

  863. 		$walker = $args[2]['walker'];

    864. 

  864. 

    865. 

  865. 	return call_user_func_array(array( &$walker, 'walk' ), $args );

    866. 

  866. }

    867. 

  867. 

    868. 

  868. /**

    869. 

  869.  * Retrieve HTML dropdown (select) content for category list.

    870. 

  870.  *

    871. 

  871.  * @uses Walker_CategoryDropdown to create HTML dropdown content.

    872. 

  872.  * @since 2.1.0

    873. 

  873.  * @see Walker_CategoryDropdown::walk() for parameters and return description.

    874. 

  874.  */

    875. 

  875. function walk_category_dropdown_tree() {

    876. 

  876. 	$args = func_get_args();

    877. 

  877. 	// the user's options are the third parameter

    878. 

  878. 	if ( empty($args[2]['walker']) || !is_a($args[2]['walker'], 'Walker') )

    879. 

  879. 		$walker = new Walker_CategoryDropdown;

    880. 

  880. 	else

    881. 

  881. 		$walker = $args[2]['walker'];

    882. 

  882. 

    883. 

  883. 	return call_user_func_array(array( &$walker, 'walk' ), $args );

    884. 

  884. }

    885. 

  885. 

    886. 

  886. /**

    887. 

  887.  * Create HTML list of categories.

    888. 

  888.  *

    889. 

  889.  * @package WordPress

    890. 

  890.  * @since 2.1.0

    891. 

  891.  * @uses Walker

    892. 

  892.  */

    893. 

  893. class Walker_Category extends Walker {

    894. 

  894. 	/**

    895. 

  895. 	 * What the class handles.

    896. 

  896. 	 *

    897. 

  897. 	 * @see Walker::$tree_type

    898. 

  898. 	 * @since 2.1.0

    899. 

  899. 	 * @var string

    900. 

  900. 	 */

    901. 

  901. 	public $tree_type = 'category';

    902. 

  902. 

    903. 

  903. 	/**

    904. 

  904. 	 * Database fields to use.

    905. 

  905. 	 *

    906. 

  906. 	 * @see Walker::$db_fields

    907. 

  907. 	 * @since 2.1.0

    908. 

  908. 	 * @todo Decouple this

    909. 

  909. 	 * @var array

    910. 

  910. 	 */

    911. 

  911. 	public $db_fields = array ('parent' => 'parent', 'id' => 'term_id');

    912. 

  912. 

    913. 

  913. 	/**

    914. 

  914. 	 * Starts the list before the elements are added.

    915. 

  915. 	 *

    916. 

  916. 	 * @see Walker::start_lvl()

    917. 

  917. 	 *

    918. 

  918. 	 * @since 2.1.0

    919. 

  919. 	 *

    920. 

  920. 	 * @param string $output Passed by reference. Used to append additional content.

    921. 

  921. 	 * @param int    $depth  Depth of category. Used for tab indentation.

    922. 

  922. 	 * @param array  $args   An array of arguments. Will only append content if style argument value is 'list'.

    923. 

  923. 	 *                       @see wp_list_categories()

    924. 

  924. 	 */

    925. 

  925. 	public function start_lvl( &$output, $depth = 0, $args = array() ) {

    926. 

  926. 		if ( 'list' != $args['style'] )

    927. 

  927. 			return;

    928. 

  928. 

    929. 

  929. 		$indent = str_repeat("\t", $depth);

    930. 

  930. 		$output .= "$indent<ul class='children'>\n";

    931. 

  931. 	}

    932. 

  932. 

    933. 

  933. 	/**

    934. 

  934. 	 * Ends the list of after the elements are added.

    935. 

  935. 	 *

    936. 

  936. 	 * @see Walker::end_lvl()

    937. 

  937. 	 *

    938. 

  938. 	 * @since 2.1.0

    939. 

  939. 	 *

    940. 

  940. 	 * @param string $output Passed by reference. Used to append additional content.

    941. 

  941. 	 * @param int    $depth  Depth of category. Used for tab indentation.

    942. 

  942. 	 * @param array  $args   An array of arguments. Will only append content if style argument value is 'list'.

    943. 

  943. 	 *                       @wsee wp_list_categories()

    944. 

  944. 	 */

    945. 

  945. 	public function end_lvl( &$output, $depth = 0, $args = array() ) {

    946. 

  946. 		if ( 'list' != $args['style'] )

    947. 

  947. 			return;

    948. 

  948. 

    949. 

  949. 		$indent = str_repeat("\t", $depth);

    950. 

  950. 		$output .= "$indent</ul>\n";

    951. 

  951. 	}

    952. 

  952. 

    953. 

  953. 	/**

    954. 

  954. 	 * Start the element output.

    955. 

  955. 	 *

    956. 

  956. 	 * @see Walker::start_el()

    957. 

  957. 	 *

    958. 

  958. 	 * @since 2.1.0

    959. 

  959. 	 *

    960. 

  960. 	 * @param string $output   Passed by reference. Used to append additional content.

    961. 

  961. 	 * @param object $category Category data object.

    962. 

  962. 	 * @param int    $depth    Depth of category in reference to parents. Default 0.

    963. 

  963. 	 * @param array  $args     An array of arguments. @see wp_list_categories()

    964. 

  964. 	 * @param int    $id       ID of the current category.

    965. 

  965. 	 */

    966. 

  966. 	public function start_el( &$output, $category, $depth = 0, $args = array(), $id = 0 ) {

    967. 

  967. 		/** This filter is documented in wp-includes/category-template.php */

    968. 

  968. 		$cat_name = apply_filters(

    969. 

  969. 			'list_cats',

    970. 

  970. 			esc_attr( $category->name ),

    971. 

  971. 			$category

    972. 

  972. 		);

    973. 

  973. 

    974. 

  974. 		$link = '<a href="' . esc_url( get_term_link( $category ) ) . '" ';

    975. 

  975. 		if ( $args['use_desc_for_title'] && ! empty( $category->description ) ) {

    976. 

  976. 			/**

    977. 

  977. 			 * Filter the category description for display.

    978. 

  978. 			 *

    979. 

  979. 			 * @since 1.2.0

    980. 

  980. 			 *

    981. 

  981. 			 * @param string $description Category description.

    982. 

  982. 			 * @param object $category    Category object.

    983. 

  983. 			 */

    984. 

  984. 			$link .= 'title="' . esc_attr( strip_tags( apply_filters( 'category_description', $category->description, $category ) ) ) . '"';

    985. 

  985. 		}

    986. 

  986. 

    987. 

  987. 		$link .= '>';

    988. 

  988. 		$link .= $cat_name . '</a>';

    989. 

  989. 

    990. 

  990. 		if ( ! empty( $args['feed_image'] ) || ! empty( $args['feed'] ) ) {

    991. 

  991. 			$link .= ' ';

    992. 

  992. 

    993. 

  993. 			if ( empty( $args['feed_image'] ) ) {

    994. 

  994. 				$link .= '(';

    995. 

  995. 			}

    996. 

  996. 

    997. 

  997. 			$link .= '<a href="' . esc_url( get_term_feed_link( $category->term_id, $category->taxonomy, $args['feed_type'] ) ) . '"';

    998. 

  998. 

    999. 

  999. 			if ( empty( $args['feed'] ) ) {

    1000. 

  1000. 				$alt = ' alt="' . sprintf(__( 'Feed for all posts filed under %s' ), $cat_name ) . '"';

    1001. 

  1001. 			} else {

    1002. 

  1002. 				$alt = ' alt="' . $args['feed'] . '"';

    1003. 

  1003. 				$name = $args['feed'];

    1004. 

  1004. 				$link .= empty( $args['title'] ) ? '' : $args['title'];

    1005. 

  1005. 			}

    1006. 

  1006. 

    1007. 

  1007. 			$link .= '>';

    1008. 

  1008. 

    1009. 

  1009. 			if ( empty( $args['feed_image'] ) ) {

    1010. 

  1010. 				$link .= $name;

    1011. 

  1011. 			} else {

    1012. 

  1012. 				$link .= "<img src='" . $args['feed_image'] . "'$alt" . ' />';

    1013. 

  1013. 			}

    1014. 

  1014. 			$link .= '</a>';

    1015. 

  1015. 

    1016. 

  1016. 			if ( empty( $args['feed_image'] ) ) {

    1017. 

  1017. 				$link .= ')';

    1018. 

  1018. 			}

    1019. 

  1019. 		}

    1020. 

  1020. 

    1021. 

  1021. 		if ( ! empty( $args['show_count'] ) ) {

    1022. 

  1022. 			$link .= ' (' . number_format_i18n( $category->count ) . ')';

    1023. 

  1023. 		}

    1024. 

  1024. 		if ( 'list' == $args['style'] ) {

    1025. 

  1025. 			$output .= "\t<li";

    1026. 

  1026. 			$class = 'cat-item cat-item-' . $category->term_id;

    1027. 

  1027. 			if ( ! empty( $args['current_category'] ) ) {

    1028. 

  1028. 				$_current_category = get_term( $args['current_category'], $category->taxonomy );

    1029. 

  1029. 				if ( $category->term_id == $args['current_category'] ) {

    1030. 

  1030. 					$class .=  ' current-cat';

    1031. 

  1031. 				} elseif ( $category->term_id == $_current_category->parent ) {

    1032. 

  1032. 					$class .=  ' current-cat-parent';

    1033. 

  1033. 				}

    1034. 

  1034. 			}

    1035. 

  1035. 			$output .=  ' class="' . $class . '"';

    1036. 

  1036. 			$output .= ">$link\n";

    1037. 

  1037. 		} else {

    1038. 

  1038. 			$output .= "\t$link<br />\n";

    1039. 

  1039. 		}

    1040. 

  1040. 	}

    1041. 

  1041. 

    1042. 

  1042. 	/**

    1043. 

  1043. 	 * Ends the element output, if needed.

    1044. 

  1044. 	 *

    1045. 

  1045. 	 * @see Walker::end_el()

    1046. 

  1046. 	 *

    1047. 

  1047. 	 * @since 2.1.0

    1048. 

  1048. 	 *

    1049. 

  1049. 	 * @param string $output Passed by reference. Used to append additional content.

    1050. 

  1050. 	 * @param object $page   Not used.

    1051. 

  1051. 	 * @param int    $depth  Depth of category. Not used.

    1052. 

  1052. 	 * @param array  $args   An array of arguments. Only uses 'list' for whether should append to output. @see wp_list_categories()

    1053. 

  1053. 	 */

    1054. 

  1054. 	public function end_el( &$output, $page, $depth = 0, $args = array() ) {

    1055. 

  1055. 		if ( 'list' != $args['style'] )

    1056. 

  1056. 			return;

    1057. 

  1057. 

    1058. 

  1058. 		$output .= "</li>\n";

    1059. 

  1059. 	}

    1060. 

  1060. 

    1061. 

  1061. }

    1062. 

  1062. 

    1063. 

  1063. /**

    1064. 

  1064.  * Create HTML dropdown list of Categories.

    1065. 

  1065.  *

    1066. 

  1066.  * @package WordPress

    1067. 

  1067.  * @since 2.1.0

    1068. 

  1068.  * @uses Walker

    1069. 

  1069.  */

    1070. 

  1070. class Walker_CategoryDropdown extends Walker {

    1071. 

  1071. 	/**

    1072. 

  1072. 	 * @see Walker::$tree_type

    1073. 

  1073. 	 * @since 2.1.0

    1074. 

  1074. 	 * @var string

    1075. 

  1075. 	 */

    1076. 

  1076. 	public $tree_type = 'category';

    1077. 

  1077. 

    1078. 

  1078. 	/**

    1079. 

  1079. 	 * @see Walker::$db_fields

    1080. 

  1080. 	 * @since 2.1.0

    1081. 

  1081. 	 * @todo Decouple this

    1082. 

  1082. 	 * @var array

    1083. 

  1083. 	 */

    1084. 

  1084. 	public $db_fields = array ('parent' => 'parent', 'id' => 'term_id');

    1085. 

  1085. 

    1086. 

  1086. 	/**

    1087. 

  1087. 	 * Start the element output.

    1088. 

  1088. 	 *

    1089. 

  1089. 	 * @see Walker::start_el()

    1090. 

  1090. 	 * @since 2.1.0

    1091. 

  1091. 	 *

    1092. 

  1092. 	 * @param string $output   Passed by reference. Used to append additional content.

    1093. 

  1093. 	 * @param object $category Category data object.

    1094. 

  1094. 	 * @param int    $depth    Depth of category. Used for padding.

    1095. 

  1095. 	 * @param array  $args     Uses 'selected' and 'show_count' keys, if they exist. @see wp_dropdown_categories()

    1096. 

  1096. 	 */

    1097. 

  1097. 	public function start_el( &$output, $category, $depth = 0, $args = array(), $id = 0 ) {

    1098. 

  1098. 		$pad = str_repeat('&nbsp;', $depth * 3);

    1099. 

  1099. 

    1100. 

  1100. 		/** This filter is documented in wp-includes/category-template.php */

    1101. 

  1101. 		$cat_name = apply_filters( 'list_cats', $category->name, $category );

    1102. 

  1102. 

    1103. 

  1103. 		$output .= "\t<option class=\"level-$depth\" value=\"".$category->term_id."\"";

    1104. 

  1104. 		if ( $category->term_id == $args['selected'] )

    1105. 

  1105. 			$output .= ' selected="selected"';

    1106. 

  1106. 		$output .= '>';

    1107. 

  1107. 		$output .= $pad.$cat_name;

    1108. 

  1108. 		if ( $args['show_count'] )

    1109. 

  1109. 			$output .= '&nbsp;&nbsp;('. number_format_i18n( $category->count ) .')';

    1110. 

  1110. 		$output .= "</option>\n";

    1111. 

  1111. 	}

    1112. 

  1112. }

    1113. 

  1113. 

    1114. 

  1114. //

    1115. 

  1115. // Tags

    1116. 

  1116. //

    1117. 

  1117. 

    1118. 

  1118. /**

    1119. 

  1119.  * Retrieve the link to the tag.

    1120. 

  1120.  *

    1121. 

  1121.  * @since 2.3.0

    1122. 

  1122.  * @see get_term_link()

    1123. 

  1123.  *

    1124. 

  1124.  * @param int|object $tag Tag ID or object.

    1125. 

  1125.  * @return string Link on success, empty string if tag does not exist.

    1126. 

  1126.  */

    1127. 

  1127. function get_tag_link( $tag ) {

    1128. 

  1128. 	if ( ! is_object( $tag ) )

    1129. 

  1129. 		$tag = (int) $tag;

    1130. 

  1130. 

    1131. 

  1131. 	$tag = get_term_link( $tag, 'post_tag' );

    1132. 

  1132. 

    1133. 

  1133. 	if ( is_wp_error( $tag ) )

    1134. 

  1134. 		return '';

    1135. 

  1135. 

    1136. 

  1136. 	return $tag;

    1137. 

  1137. }

    1138. 

  1138. 

    1139. 

  1139. /**

    1140. 

  1140.  * Retrieve the tags for a post.

    1141. 

  1141.  *

    1142. 

  1142.  * @since 2.3.0

    1143. 

  1143.  *

    1144. 

  1144.  * @param int $id Post ID.

    1145. 

  1145.  * @return array|bool Array of tag objects on success, false on failure.

    1146. 

  1146.  */

    1147. 

  1147. function get_the_tags( $id = 0 ) {

    1148. 

  1148. 

    1149. 

  1149. 	/**

    1150. 

  1150. 	 * Filter the array of tags for the given post.

    1151. 

  1151. 	 *

    1152. 

  1152. 	 * @since 2.3.0

    1153. 

  1153. 	 *

    1154. 

  1154. 	 * @see get_the_terms()

    1155. 

  1155. 	 *

    1156. 

  1156. 	 * @param array $terms An array of tags for the given post.

    1157. 

  1157. 	 */

    1158. 

  1158. 	return apply_filters( 'get_the_tags', get_the_terms( $id, 'post_tag' ) );

    1159. 

  1159. }

    1160. 

  1160. 

    1161. 

  1161. /**

    1162. 

  1162.  * Retrieve the tags for a post formatted as a string.

    1163. 

  1163.  *

    1164. 

  1164.  * @since 2.3.0

    1165. 

  1165.  *

    1166. 

  1166.  * @param string $before Optional. Before tags.

    1167. 

  1167.  * @param string $sep Optional. Between tags.

    1168. 

  1168.  * @param string $after Optional. After tags.

    1169. 

  1169.  * @param int $id Optional. Post ID. Defaults to the current post.

    1170. 

  1170.  * @return string|bool|WP_Error A list of tags on success, false if there are no terms, WP_Error on failure.

    1171. 

  1171.  */

    1172. 

  1172. function get_the_tag_list( $before = '', $sep = '', $after = '', $id = 0 ) {

    1173. 

  1173. 

    1174. 

  1174. 	/**

    1175. 

  1175. 	 * Filter the tags list for a given post.

    1176. 

  1176. 	 *

    1177. 

  1177. 	 * @since 2.3.0

    1178. 

  1178. 	 *

    1179. 

  1179. 	 * @param string $tag_list List of tags.

    1180. 

  1180. 	 * @param string $before   String to use before tags.

    1181. 

  1181. 	 * @param string $sep      String to use between the tags.

    1182. 

  1182. 	 * @param string $after    String to use after tags.

    1183. 

  1183. 	 * @param int    $id       Post ID.

    1184. 

  1184. 	 */

    1185. 

  1185. 	return apply_filters( 'the_tags', get_the_term_list( $id, 'post_tag', $before, $sep, $after ), $before, $sep, $after, $id );

    1186. 

  1186. }

    1187. 

  1187. 

    1188. 

  1188. /**

    1189. 

  1189.  * Retrieve the tags for a post.

    1190. 

  1190.  *

    1191. 

  1191.  * @since 2.3.0

    1192. 

  1192.  *

    1193. 

  1193.  * @param string $before Optional. Before list.

    1194. 

  1194.  * @param string $sep Optional. Separate items using this.

    1195. 

  1195.  * @param string $after Optional. After list.

    1196. 

  1196.  */

    1197. 

  1197. function the_tags( $before = null, $sep = ', ', $after = '' ) {

    1198. 

  1198. 	if ( null === $before )

    1199. 

  1199. 		$before = __('Tags: ');

    1200. 

  1200. 	echo get_the_tag_list($before, $sep, $after);

    1201. 

  1201. }

    1202. 

  1202. 

    1203. 

  1203. /**

    1204. 

  1204.  * Retrieve tag description.

    1205. 

  1205.  *

    1206. 

  1206.  * @since 2.8.0

    1207. 

  1207.  *

    1208. 

  1208.  * @param int $tag Optional. Tag ID. Will use global tag ID by default.

    1209. 

  1209.  * @return string Tag description, available.

    1210. 

  1210.  */

    1211. 

  1211. function tag_description( $tag = 0 ) {

    1212. 

  1212. 	return term_description( $tag );

    1213. 

  1213. }

    1214. 

  1214. 

    1215. 

  1215. /**

    1216. 

  1216.  * Retrieve term description.

    1217. 

  1217.  *

    1218. 

  1218.  * @since 2.8.0

    1219. 

  1219.  *

    1220. 

  1220.  * @param int $term Optional. Term ID. Will use global term ID by default.

    1221. 

  1221.  * @param string $taxonomy Optional taxonomy name. Defaults to 'post_tag'.

    1222. 

  1222.  * @return string Term description, available.

    1223. 

  1223.  */

    1224. 

  1224. function term_description( $term = 0, $taxonomy = 'post_tag' ) {

    1225. 

  1225. 	if ( ! $term && ( is_tax() || is_tag() || is_category() ) ) {

    1226. 

  1226. 		$term = get_queried_object();

    1227. 

  1227. 		if ( $term ) {

    1228. 

  1228. 			$taxonomy = $term->taxonomy;

    1229. 

  1229. 			$term = $term->term_id;

    1230. 

  1230. 		}

    1231. 

  1231. 	}

    1232. 

  1232. 	$description = get_term_field( 'description', $term, $taxonomy );

    1233. 

  1233. 	return is_wp_error( $description ) ? '' : $description;

    1234. 

  1234. }

    1235. 

  1235. 

    1236. 

  1236. /**

    1237. 

  1237.  * Retrieve the terms of the taxonomy that are attached to the post.

    1238. 

  1238.  *

    1239. 

  1239.  * @since 2.5.0

    1240. 

  1240.  *

    1241. 

  1241.  * @param int|object $post Post ID or object.

    1242. 

  1242.  * @param string $taxonomy Taxonomy name.

    1243. 

  1243.  * @return array|bool|WP_Error Array of term objects on success, false if there are no terms

    1244. 

  1244.  *                             or the post does not exist, WP_Error on failure.

    1245. 

  1245.  */

    1246. 

  1246. function get_the_terms( $post, $taxonomy ) {

    1247. 

  1247. 	if ( ! $post = get_post( $post ) )

    1248. 

  1248. 		return false;

    1249. 

  1249. 

    1250. 

  1250. 	$terms = get_object_term_cache( $post->ID, $taxonomy );

    1251. 

  1251. 	if ( false === $terms ) {

    1252. 

  1252. 		$terms = wp_get_object_terms( $post->ID, $taxonomy );

    1253. 

  1253. 		wp_cache_add($post->ID, $terms, $taxonomy . '_relationships');

    1254. 

  1254. 	}

    1255. 

  1255. 

    1256. 

  1256. 	/**

    1257. 

  1257. 	 * Filter the list of terms attached to the given post.

    1258. 

  1258. 	 *

    1259. 

  1259. 	 * @since 3.1.0

    1260. 

  1260. 	 *

    1261. 

  1261. 	 * @param array|WP_Error $terms    List of attached terms, or WP_Error on failure.

    1262. 

  1262. 	 * @param int            $post_id  Post ID.

    1263. 

  1263. 	 * @param string         $taxonomy Name of the taxonomy.

    1264. 

  1264. 	 */

    1265. 

  1265. 	$terms = apply_filters( 'get_the_terms', $terms, $post->ID, $taxonomy );

    1266. 

  1266. 

    1267. 

  1267. 	if ( empty( $terms ) )

    1268. 

  1268. 		return false;

    1269. 

  1269. 

    1270. 

  1270. 	return $terms;

    1271. 

  1271. }

    1272. 

  1272. 

    1273. 

  1273. /**

    1274. 

  1274.  * Retrieve a post's terms as a list with specified format.

    1275. 

  1275.  *

    1276. 

  1276.  * @since 2.5.0

    1277. 

  1277.  *

    1278. 

  1278.  * @param int $id Post ID.

    1279. 

  1279.  * @param string $taxonomy Taxonomy name.

    1280. 

  1280.  * @param string $before Optional. Before list.

    1281. 

  1281.  * @param string $sep Optional. Separate items using this.

    1282. 

  1282.  * @param string $after Optional. After list.

    1283. 

  1283.  * @return string|bool|WP_Error A list of terms on success, false if there are no terms, WP_Error on failure.

    1284. 

  1284.  */

    1285. 

  1285. function get_the_term_list( $id, $taxonomy, $before = '', $sep = '', $after = '' ) {

    1286. 

  1286. 	$terms = get_the_terms( $id, $taxonomy );

    1287. 

  1287. 

    1288. 

  1288. 	if ( is_wp_error( $terms ) )

    1289. 

  1289. 		return $terms;

    1290. 

  1290. 

    1291. 

  1291. 	if ( empty( $terms ) )

    1292. 

  1292. 		return false;

    1293. 

  1293. 

    1294. 

  1294. 	foreach ( $terms as $term ) {

    1295. 

  1295. 		$link = get_term_link( $term, $taxonomy );

    1296. 

  1296. 		if ( is_wp_error( $link ) )

    1297. 

  1297. 			return $link;

    1298. 

  1298. 		$term_links[] = '<a href="' . esc_url( $link ) . '" rel="tag">' . $term->name . '</a>';

    1299. 

  1299. 	}

    1300. 

  1300. 

    1301. 

  1301. 	/**

    1302. 

  1302. 	 * Filter the term links for a given taxonomy.

    1303. 

  1303. 	 *

    1304. 

  1304. 	 * The dynamic portion of the filter name, $taxonomy, refers

    1305. 

  1305. 	 * to the taxonomy slug.

    1306. 

  1306. 	 *

    1307. 

  1307. 	 * @since 2.5.0

    1308. 

  1308. 	 *

    1309. 

  1309. 	 * @param array $term_links An array of term links.

    1310. 

  1310. 	 */

    1311. 

  1311. 	$term_links = apply_filters( "term_links-$taxonomy", $term_links );

    1312. 

  1312. 

    1313. 

  1313. 	return $before . join( $sep, $term_links ) . $after;

    1314. 

  1314. }

    1315. 

  1315. 

    1316. 

  1316. /**

    1317. 

  1317.  * Display the terms in a list.

    1318. 

  1318.  *

    1319. 

  1319.  * @since 2.5.0

    1320. 

  1320.  *

    1321. 

  1321.  * @param int $id Post ID.

    1322. 

  1322.  * @param string $taxonomy Taxonomy name.

    1323. 

  1323.  * @param string $before Optional. Before list.

    1324. 

  1324.  * @param string $sep Optional. Separate items using this.

    1325. 

  1325.  * @param string $after Optional. After list.

    1326. 

  1326.  * @return null|bool False on WordPress error. Returns null when displaying.

    1327. 

  1327.  */

    1328. 

  1328. function the_terms( $id, $taxonomy, $before = '', $sep = ', ', $after = '' ) {

    1329. 

  1329. 	$term_list = get_the_term_list( $id, $taxonomy, $before, $sep, $after );

    1330. 

  1330. 

    1331. 

  1331. 	if ( is_wp_error( $term_list ) )

    1332. 

  1332. 		return false;

    1333. 

  1333. 

    1334. 

  1334. 	/**

    1335. 

  1335. 	 * Filter the list of terms to display.

    1336. 

  1336. 	 *

    1337. 

  1337. 	 * @since 2.9.0

    1338. 

  1338. 	 *

    1339. 

  1339. 	 * @param array  $term_list List of terms to display.

    1340. 

  1340. 	 * @param string $taxonomy  The taxonomy name.

    1341. 

  1341. 	 * @param string $before    String to use before the terms.

    1342. 

  1342. 	 * @param string $sep       String to use between the terms.

    1343. 

  1343. 	 * @param string $after     String to use after the terms.

    1344. 

  1344. 	 */

    1345. 

  1345. 	echo apply_filters( 'the_terms', $term_list, $taxonomy, $before, $sep, $after );

    1346. 

  1346. }

    1347. 

  1347. 

    1348. 

  1348. /**

    1349. 

  1349.  * Check if the current post has any of given category.

    1350. 

  1350.  *

    1351. 

  1351.  * @since 3.1.0

    1352. 

  1352.  *

    1353. 

  1353.  * @param string|int|array $category Optional. The category name/term_id/slug or array of them to check for.

    1354. 

  1354.  * @param int|object $post Optional. Post to check instead of the current post.

    1355. 

  1355.  * @return bool True if the current post has any of the given categories (or any category, if no category specified).

    1356. 

  1356.  */

    1357. 

  1357. function has_category( $category = '', $post = null ) {

    1358. 

  1358. 	return has_term( $category, 'category', $post );

    1359. 

  1359. }

    1360. 

  1360. 

    1361. 

  1361. /**

    1362. 

  1362.  * Check if the current post has any of given tags.

    1363. 

  1363.  *

    1364. 

  1364.  * The given tags are checked against the post's tags' term_ids, names and slugs.

    1365. 

  1365.  * Tags given as integers will only be checked against the post's tags' term_ids.

    1366. 

  1366.  * If no tags are given, determines if post has any tags.

    1367. 

  1367.  *

    1368. 

  1368.  * Prior to v2.7 of WordPress, tags given as integers would also be checked against the post's tags' names and slugs (in addition to term_ids)

    1369. 

  1369.  * Prior to v2.7, this function could only be used in the WordPress Loop.

    1370. 

  1370.  * As of 2.7, the function can be used anywhere if it is provided a post ID or post object.

    1371. 

  1371.  *

    1372. 

  1372.  * @since 2.6.0

    1373. 

  1373.  *

    1374. 

  1374.  * @param string|int|array $tag Optional. The tag name/term_id/slug or array of them to check for.

    1375. 

  1375.  * @param int|object $post Optional. Post to check instead of the current post. (since 2.7.0)

    1376. 

  1376.  * @return bool True if the current post has any of the given tags (or any tag, if no tag specified).

    1377. 

  1377.  */

    1378. 

  1378. function has_tag( $tag = '', $post = null ) {

    1379. 

  1379. 	return has_term( $tag, 'post_tag', $post );

    1380. 

  1380. }

    1381. 

  1381. 

    1382. 

  1382. /**

    1383. 

  1383.  * Check if the current post has any of given terms.

    1384. 

  1384.  *

    1385. 

  1385.  * The given terms are checked against the post's terms' term_ids, names and slugs.

    1386. 

  1386.  * Terms given as integers will only be checked against the post's terms' term_ids.

    1387. 

  1387.  * If no terms are given, determines if post has any terms.

    1388. 

  1388.  *

    1389. 

  1389.  * @since 3.1.0

    1390. 

  1390.  *

    1391. 

  1391.  * @param string|int|array $term Optional. The term name/term_id/slug or array of them to check for.

    1392. 

  1392.  * @param string $taxonomy Taxonomy name

    1393. 

  1393.  * @param int|object $post Optional. Post to check instead of the current post.

    1394. 

  1394.  * @return bool True if the current post has any of the given tags (or any tag, if no tag specified).

    1395. 

  1395.  */

    1396. 

  1396. function has_term( $term = '', $taxonomy = '', $post = null ) {

    1397. 

  1397. 	$post = get_post($post);

    1398. 

  1398. 

    1399. 

  1399. 	if ( !$post )

    1400. 

  1400. 		return false;

    1401. 

  1401. 

    1402. 

  1402. 	$r = is_object_in_term( $post->ID, $taxonomy, $term );

    1403. 

  1403. 	if ( is_wp_error( $r ) )

    1404. 

  1404. 		return false;

    1405. 

  1405. 

    1406. 

  1406. 	return $r;

    1407. 

  1407. }

    1408. 

  1408.