PageRenderTime 60ms CodeModel.GetById 32ms RepoModel.GetById 1ms app.codeStats 0ms

/blog/wp-includes/nav-menu.php

https://bitbucket.org/my30dc/my30dc.com
PHP | 786 lines | 437 code | 127 blank | 222 comment | 116 complexity | fdf2b7223a2f77bef4dc1ad0b2957c84 MD5 | raw file
Possible License(s): GPL-2.0, AGPL-1.0, LGPL-2.1
  1. <?php
  2. /**
  3. * Navigation Menu functions
  4. *
  5. * @package WordPress
  6. * @subpackage Nav_Menus
  7. * @since 3.0.0
  8. */
  9. /**
  10. * Returns a navigation menu object.
  11. *
  12. * @since 3.0.0
  13. *
  14. * @uses get_term
  15. * @uses get_term_by
  16. *
  17. * @param string $menu Menu id, slug or name
  18. * @return mixed false if $menu param isn't supplied or term does not exist, menu object if successful.
  19. */
  20. function wp_get_nav_menu_object( $menu ) {
  21. if ( ! $menu )
  22. return false;
  23. $menu_obj = get_term( $menu, 'nav_menu' );
  24. if ( ! $menu_obj )
  25. $menu_obj = get_term_by( 'slug', $menu, 'nav_menu' );
  26. if ( ! $menu_obj )
  27. $menu_obj = get_term_by( 'name', $menu, 'nav_menu' );
  28. if ( ! $menu_obj )
  29. $menu_obj = false;
  30. return $menu_obj;
  31. }
  32. /**
  33. * Check if the given ID is a navigation menu.
  34. *
  35. * Returns true if it is; false otherwise.
  36. *
  37. * @since 3.0.0
  38. *
  39. * @param int|string $menu The menu to check (id, slug, or name)
  40. * @return bool Whether the menu exists.
  41. */
  42. function is_nav_menu( $menu ) {
  43. if ( ! $menu )
  44. return false;
  45. $menu_obj = wp_get_nav_menu_object( $menu );
  46. if (
  47. $menu_obj &&
  48. ! is_wp_error( $menu_obj ) &&
  49. ! empty( $menu_obj->taxonomy ) &&
  50. 'nav_menu' == $menu_obj->taxonomy
  51. )
  52. return true;
  53. return false;
  54. }
  55. /**
  56. * Register navigation menus for a theme.
  57. *
  58. * @since 3.0.0
  59. *
  60. * @param array $locations Associative array of menu location identifiers (like a slug) and descriptive text.
  61. */
  62. function register_nav_menus( $locations = array() ) {
  63. global $_wp_registered_nav_menus;
  64. add_theme_support( 'menus' );
  65. $_wp_registered_nav_menus = array_merge( (array) $_wp_registered_nav_menus, $locations );
  66. }
  67. /**
  68. * Unregisters a navigation menu for a theme.
  69. *
  70. * @param array $location the menu location identifier
  71. *
  72. * @return bool True on success, false on failure.
  73. */
  74. function unregister_nav_menu( $location ) {
  75. global $_wp_registered_nav_menus;
  76. if ( is_array( $_wp_registered_nav_menus ) && isset( $_wp_registered_nav_menus[$location] ) ) {
  77. unset( $_wp_registered_nav_menus[$location] );
  78. return true;
  79. }
  80. return false;
  81. }
  82. /**
  83. * Register a navigation menu for a theme.
  84. *
  85. * @since 3.0.0
  86. *
  87. * @param string $location Menu location identifier, like a slug.
  88. * @param string $description Menu location descriptive text.
  89. */
  90. function register_nav_menu( $location, $description ) {
  91. register_nav_menus( array( $location => $description ) );
  92. }
  93. /**
  94. * Returns an array of all registered navigation menus in a theme
  95. *
  96. * @since 3.0.0
  97. * @return array
  98. */
  99. function get_registered_nav_menus() {
  100. global $_wp_registered_nav_menus;
  101. if ( isset( $_wp_registered_nav_menus ) )
  102. return $_wp_registered_nav_menus;
  103. return array();
  104. }
  105. /**
  106. * Returns an array with the registered navigation menu locations and the menu assigned to it
  107. *
  108. * @since 3.0.0
  109. * @return array
  110. */
  111. function get_nav_menu_locations() {
  112. return get_theme_mod( 'nav_menu_locations' );
  113. }
  114. /**
  115. * Whether a registered nav menu location has a menu assigned to it.
  116. *
  117. * @since 3.0.0
  118. * @param string $location Menu location identifier.
  119. * @return bool Whether location has a menu.
  120. */
  121. function has_nav_menu( $location ) {
  122. $locations = get_nav_menu_locations();
  123. return ( ! empty( $locations[ $location ] ) );
  124. }
  125. /**
  126. * Determine whether the given ID is a nav menu item.
  127. *
  128. * @since 3.0.0
  129. *
  130. * @param int $menu_item_id The ID of the potential nav menu item.
  131. * @return bool Whether the given ID is that of a nav menu item.
  132. */
  133. function is_nav_menu_item( $menu_item_id = 0 ) {
  134. return ( ! is_wp_error( $menu_item_id ) && ( 'nav_menu_item' == get_post_type( $menu_item_id ) ) );
  135. }
  136. /**
  137. * Create a Navigation Menu.
  138. *
  139. * @since 3.0.0
  140. *
  141. * @param string $menu_name Menu Name
  142. * @return mixed Menu object on success|WP_Error on failure
  143. */
  144. function wp_create_nav_menu( $menu_name ) {
  145. return wp_update_nav_menu_object( 0, array( 'menu-name' => $menu_name ) );
  146. }
  147. /**
  148. * Delete a Navigation Menu.
  149. *
  150. * @since 3.0.0
  151. *
  152. * @param string $menu name|id|slug
  153. * @return mixed Menu object on success|WP_Error on failure
  154. */
  155. function wp_delete_nav_menu( $menu ) {
  156. $menu = wp_get_nav_menu_object( $menu );
  157. if ( ! $menu )
  158. return false;
  159. $menu_objects = get_objects_in_term( $menu->term_id, 'nav_menu' );
  160. if ( ! empty( $menu_objects ) ) {
  161. foreach ( $menu_objects as $item ) {
  162. wp_delete_post( $item );
  163. }
  164. }
  165. $result = wp_delete_term( $menu->term_id, 'nav_menu' );
  166. if ( $result && !is_wp_error($result) )
  167. do_action( 'wp_delete_nav_menu', $menu->term_id );
  168. return $result;
  169. }
  170. /**
  171. * Save the properties of a menu or create a new menu with those properties.
  172. *
  173. * @since 3.0.0
  174. *
  175. * @param int $menu_id The ID of the menu or "0" to create a new menu.
  176. * @param array $menu_data The array of menu data.
  177. * @return int|error object The menu's ID or WP_Error object.
  178. */
  179. function wp_update_nav_menu_object( $menu_id = 0, $menu_data = array() ) {
  180. $menu_id = (int) $menu_id;
  181. $_menu = wp_get_nav_menu_object( $menu_id );
  182. $args = array(
  183. 'description' => ( isset( $menu_data['description'] ) ? $menu_data['description'] : '' ),
  184. 'name' => ( isset( $menu_data['menu-name'] ) ? $menu_data['menu-name'] : '' ),
  185. 'parent' => ( isset( $menu_data['parent'] ) ? (int) $menu_data['parent'] : 0 ),
  186. 'slug' => null,
  187. );
  188. // double-check that we're not going to have one menu take the name of another
  189. $_possible_existing = get_term_by( 'name', $menu_data['menu-name'], 'nav_menu' );
  190. if (
  191. $_possible_existing &&
  192. ! is_wp_error( $_possible_existing ) &&
  193. isset( $_possible_existing->term_id ) &&
  194. $_possible_existing->term_id != $menu_id
  195. )
  196. return new WP_Error( 'menu_exists', sprintf( __('The menu name <strong>%s</strong> conflicts with another menu name. Please try another.'), esc_html( $menu_data['menu-name'] ) ) );
  197. // menu doesn't already exist, so create a new menu
  198. if ( ! $_menu || is_wp_error( $_menu ) ) {
  199. $menu_exists = get_term_by( 'name', $menu_data['menu-name'], 'nav_menu' );
  200. if ( $menu_exists )
  201. return new WP_Error( 'menu_exists', sprintf( __('The menu name <strong>%s</strong> conflicts with another menu name. Please try another.'), esc_html( $menu_data['menu-name'] ) ) );
  202. $_menu = wp_insert_term( $menu_data['menu-name'], 'nav_menu', $args );
  203. if ( is_wp_error( $_menu ) )
  204. return $_menu;
  205. do_action( 'wp_create_nav_menu', $_menu['term_id'], $menu_data );
  206. return (int) $_menu['term_id'];
  207. }
  208. if ( ! $_menu || ! isset( $_menu->term_id ) )
  209. return 0;
  210. $menu_id = (int) $_menu->term_id;
  211. $update_response = wp_update_term( $menu_id, 'nav_menu', $args );
  212. if ( is_wp_error( $update_response ) )
  213. return $update_response;
  214. do_action( 'wp_update_nav_menu', $menu_id, $menu_data );
  215. return $menu_id;
  216. }
  217. /**
  218. * Save the properties of a menu item or create a new one.
  219. *
  220. * @since 3.0.0
  221. *
  222. * @param int $menu_id The ID of the menu. Required. If "0", makes the menu item a draft orphan.
  223. * @param int $menu_item_db_id The ID of the menu item. If "0", creates a new menu item.
  224. * @param array $menu_item_data The menu item's data.
  225. * @return int The menu item's database ID or WP_Error object on failure.
  226. */
  227. function wp_update_nav_menu_item( $menu_id = 0, $menu_item_db_id = 0, $menu_item_data = array() ) {
  228. $menu_id = (int) $menu_id;
  229. $menu_item_db_id = (int) $menu_item_db_id;
  230. // make sure that we don't convert non-nav_menu_item objects into nav_menu_item objects
  231. if ( ! empty( $menu_item_db_id ) && ! is_nav_menu_item( $menu_item_db_id ) )
  232. return new WP_Error('update_nav_menu_item_failed', __('The given object ID is not that of a menu item.'));
  233. $menu = wp_get_nav_menu_object( $menu_id );
  234. if ( ( ! $menu && 0 !== $menu_id ) || is_wp_error( $menu ) )
  235. return $menu;
  236. $menu_items = 0 == $menu_id ? array() : (array) wp_get_nav_menu_items( $menu_id, array( 'post_status' => 'publish,draft' ) );
  237. $count = count( $menu_items );
  238. $defaults = array(
  239. 'menu-item-db-id' => $menu_item_db_id,
  240. 'menu-item-object-id' => 0,
  241. 'menu-item-object' => '',
  242. 'menu-item-parent-id' => 0,
  243. 'menu-item-position' => 0,
  244. 'menu-item-type' => 'custom',
  245. 'menu-item-title' => '',
  246. 'menu-item-url' => '',
  247. 'menu-item-description' => '',
  248. 'menu-item-attr-title' => '',
  249. 'menu-item-target' => '',
  250. 'menu-item-classes' => '',
  251. 'menu-item-xfn' => '',
  252. 'menu-item-status' => '',
  253. );
  254. $args = wp_parse_args( $menu_item_data, $defaults );
  255. if ( 0 == $menu_id ) {
  256. $args['menu-item-position'] = 1;
  257. } elseif ( 0 == (int) $args['menu-item-position'] ) {
  258. $last_item = array_pop( $menu_items );
  259. $args['menu-item-position'] = ( $last_item && isset( $last_item->menu_order ) ) ? 1 + $last_item->menu_order : $count;
  260. }
  261. $original_parent = 0 < $menu_item_db_id ? get_post_field( 'post_parent', $menu_item_db_id ) : 0;
  262. if ( 'custom' != $args['menu-item-type'] ) {
  263. /* if non-custom menu item, then:
  264. * use original object's URL
  265. * blank default title to sync with original object's
  266. */
  267. $args['menu-item-url'] = '';
  268. $original_title = '';
  269. if ( 'taxonomy' == $args['menu-item-type'] ) {
  270. $original_parent = get_term_field( 'parent', $args['menu-item-object-id'], $args['menu-item-object'], 'raw' );
  271. $original_title = get_term_field( 'name', $args['menu-item-object-id'], $args['menu-item-object'], 'raw' );
  272. } elseif ( 'post_type' == $args['menu-item-type'] ) {
  273. $original_object = get_post( $args['menu-item-object-id'] );
  274. $original_parent = (int) $original_object->post_parent;
  275. $original_title = $original_object->post_title;
  276. }
  277. if ( empty( $args['menu-item-title'] ) || $args['menu-item-title'] == $original_title ) {
  278. $args['menu-item-title'] = '';
  279. // hack to get wp to create a post object when too many properties are empty
  280. if ( empty( $args['menu-item-description'] ) )
  281. $args['menu-item-description'] = ' ';
  282. }
  283. }
  284. // Populate the menu item object
  285. $post = array(
  286. 'menu_order' => $args['menu-item-position'],
  287. 'ping_status' => 0,
  288. 'post_content' => $args['menu-item-description'],
  289. 'post_excerpt' => $args['menu-item-attr-title'],
  290. 'post_parent' => $original_parent,
  291. 'post_title' => $args['menu-item-title'],
  292. 'post_type' => 'nav_menu_item',
  293. );
  294. if ( 0 != $menu_id )
  295. $post['tax_input'] = array( 'nav_menu' => array( intval( $menu->term_id ) ) );
  296. // New menu item. Default is draft status
  297. if ( 0 == $menu_item_db_id ) {
  298. $post['ID'] = 0;
  299. $post['post_status'] = 'publish' == $args['menu-item-status'] ? 'publish' : 'draft';
  300. $menu_item_db_id = wp_insert_post( $post );
  301. // Update existing menu item. Default is publish status
  302. } else {
  303. $post['ID'] = $menu_item_db_id;
  304. $post['post_status'] = 'draft' == $args['menu-item-status'] ? 'draft' : 'publish';
  305. wp_update_post( $post );
  306. }
  307. if ( 'custom' == $args['menu-item-type'] ) {
  308. $args['menu-item-object-id'] = $menu_item_db_id;
  309. $args['menu-item-object'] = 'custom';
  310. }
  311. if ( ! $menu_item_db_id || is_wp_error( $menu_item_db_id ) )
  312. return $menu_item_db_id;
  313. $menu_item_db_id = (int) $menu_item_db_id;
  314. update_post_meta( $menu_item_db_id, '_menu_item_type', sanitize_key($args['menu-item-type']) );
  315. update_post_meta( $menu_item_db_id, '_menu_item_menu_item_parent', (int) $args['menu-item-parent-id'] );
  316. update_post_meta( $menu_item_db_id, '_menu_item_object_id', (int) $args['menu-item-object-id'] );
  317. update_post_meta( $menu_item_db_id, '_menu_item_object', sanitize_key($args['menu-item-object']) );
  318. update_post_meta( $menu_item_db_id, '_menu_item_target', sanitize_key($args['menu-item-target']) );
  319. $args['menu-item-classes'] = array_map( 'sanitize_html_class', explode( ' ', $args['menu-item-classes'] ) );
  320. $args['menu-item-xfn'] = implode( ' ', array_map( 'sanitize_html_class', explode( ' ', $args['menu-item-xfn'] ) ) );
  321. update_post_meta( $menu_item_db_id, '_menu_item_classes', $args['menu-item-classes'] );
  322. update_post_meta( $menu_item_db_id, '_menu_item_xfn', $args['menu-item-xfn'] );
  323. update_post_meta( $menu_item_db_id, '_menu_item_url', esc_url_raw($args['menu-item-url']) );
  324. if ( 0 == $menu_id )
  325. update_post_meta( $menu_item_db_id, '_menu_item_orphaned', time() );
  326. else
  327. delete_post_meta( $menu_item_db_id, '_menu_item_orphaned' );
  328. do_action('wp_update_nav_menu_item', $menu_id, $menu_item_db_id, $args );
  329. return $menu_item_db_id;
  330. }
  331. /**
  332. * Returns all navigation menu objects.
  333. *
  334. * @since 3.0.0
  335. *
  336. * @param array $args Array of arguments passed on to get_terms().
  337. * @return array menu objects
  338. */
  339. function wp_get_nav_menus( $args = array() ) {
  340. $defaults = array( 'hide_empty' => false, 'orderby' => 'none' );
  341. $args = wp_parse_args( $args, $defaults );
  342. return apply_filters( 'wp_get_nav_menus', get_terms( 'nav_menu', $args), $args );
  343. }
  344. /**
  345. * Sort menu items by the desired key.
  346. *
  347. * @since 3.0.0
  348. * @access private
  349. *
  350. * @param object $a The first object to compare
  351. * @param object $b The second object to compare
  352. * @return int -1, 0, or 1 if $a is considered to be respectively less than, equal to, or greater than $b.
  353. */
  354. function _sort_nav_menu_items( $a, $b ) {
  355. global $_menu_item_sort_prop;
  356. if ( empty( $_menu_item_sort_prop ) )
  357. return 0;
  358. if ( ! isset( $a->$_menu_item_sort_prop ) || ! isset( $b->$_menu_item_sort_prop ) )
  359. return 0;
  360. $_a = (int) $a->$_menu_item_sort_prop;
  361. $_b = (int) $b->$_menu_item_sort_prop;
  362. if ( $a->$_menu_item_sort_prop == $b->$_menu_item_sort_prop )
  363. return 0;
  364. elseif ( $_a == $a->$_menu_item_sort_prop && $_b == $b->$_menu_item_sort_prop )
  365. return $_a < $_b ? -1 : 1;
  366. else
  367. return strcmp( $a->$_menu_item_sort_prop, $b->$_menu_item_sort_prop );
  368. }
  369. /**
  370. * Returns if a menu item is valid. Bug #13958
  371. *
  372. * @since 3.2.0
  373. * @access private
  374. *
  375. * @param object $menu_item The menu item to check
  376. * @return bool false if invalid, else true.
  377. */
  378. function _is_valid_nav_menu_item( $item ) {
  379. if ( ! empty( $item->_invalid ) )
  380. return false;
  381. return true;
  382. }
  383. /**
  384. * Returns all menu items of a navigation menu.
  385. *
  386. * @since 3.0.0
  387. *
  388. * @param string $menu menu name, id, or slug
  389. * @param string $args
  390. * @return mixed $items array of menu items, else false.
  391. */
  392. function wp_get_nav_menu_items( $menu, $args = array() ) {
  393. global $_wp_using_ext_object_cache;
  394. $menu = wp_get_nav_menu_object( $menu );
  395. if ( ! $menu )
  396. return false;
  397. static $fetched = array();
  398. $items = get_objects_in_term( $menu->term_id, 'nav_menu' );
  399. if ( empty( $items ) )
  400. return $items;
  401. $defaults = array( 'order' => 'ASC', 'orderby' => 'menu_order', 'post_type' => 'nav_menu_item',
  402. 'post_status' => 'publish', 'output' => ARRAY_A, 'output_key' => 'menu_order', 'nopaging' => true,
  403. 'update_post_term_cache' => false );
  404. $args = wp_parse_args( $args, $defaults );
  405. if ( count( $items ) > 1 )
  406. $args['include'] = implode( ',', $items );
  407. else
  408. $args['include'] = $items[0];
  409. $items = get_posts( $args );
  410. if ( is_wp_error( $items ) || ! is_array( $items ) )
  411. return false;
  412. // Get all posts and terms at once to prime the caches
  413. if ( empty( $fetched[$menu->term_id] ) || $_wp_using_ext_object_cache ) {
  414. $fetched[$menu->term_id] = true;
  415. $posts = array();
  416. $terms = array();
  417. foreach ( $items as $item ) {
  418. $object_id = get_post_meta( $item->ID, '_menu_item_object_id', true );
  419. $object = get_post_meta( $item->ID, '_menu_item_object', true );
  420. $type = get_post_meta( $item->ID, '_menu_item_type', true );
  421. if ( 'post_type' == $type )
  422. $posts[$object][] = $object_id;
  423. elseif ( 'taxonomy' == $type)
  424. $terms[$object][] = $object_id;
  425. }
  426. if ( ! empty( $posts ) ) {
  427. foreach ( array_keys($posts) as $post_type ) {
  428. get_posts( array('post__in' => $posts[$post_type], 'post_type' => $post_type, 'nopaging' => true, 'update_post_term_cache' => false) );
  429. }
  430. }
  431. unset($posts);
  432. if ( ! empty( $terms ) ) {
  433. foreach ( array_keys($terms) as $taxonomy ) {
  434. get_terms($taxonomy, array('include' => $terms[$taxonomy]) );
  435. }
  436. }
  437. unset($terms);
  438. }
  439. $items = array_map( 'wp_setup_nav_menu_item', $items );
  440. if ( ! is_admin() ) // Remove invalid items only in frontend
  441. $items = array_filter( $items, '_is_valid_nav_menu_item' );
  442. if ( ARRAY_A == $args['output'] ) {
  443. $GLOBALS['_menu_item_sort_prop'] = $args['output_key'];
  444. usort($items, '_sort_nav_menu_items');
  445. $i = 1;
  446. foreach( $items as $k => $item ) {
  447. $items[$k]->$args['output_key'] = $i++;
  448. }
  449. }
  450. return apply_filters( 'wp_get_nav_menu_items', $items, $menu, $args );
  451. }
  452. /**
  453. * Decorates a menu item object with the shared navigation menu item properties.
  454. *
  455. * Properties:
  456. * - db_id: The DB ID of this item as a nav_menu_item object, if it exists (0 if it doesn't exist).
  457. * - object_id: The DB ID of the original object this menu item represents, e.g. ID for posts and term_id for categories.
  458. * - type: The family of objects originally represented, such as "post_type" or "taxonomy."
  459. * - object: The type of object originally represented, such as "category," "post", or "attachment."
  460. * - type_label: The singular label used to describe this type of menu item.
  461. * - post_parent: The DB ID of the original object's parent object, if any (0 otherwise).
  462. * - menu_item_parent: The DB ID of the nav_menu_item that is this item's menu parent, if any. 0 otherwise.
  463. * - url: The URL to which this menu item points.
  464. * - title: The title of this menu item.
  465. * - target: The target attribute of the link element for this menu item.
  466. * - attr_title: The title attribute of the link element for this menu item.
  467. * - classes: The array of class attribute values for the link element of this menu item.
  468. * - xfn: The XFN relationship expressed in the link of this menu item.
  469. * - description: The description of this menu item.
  470. *
  471. * @since 3.0.0
  472. *
  473. * @param object $menu_item The menu item to modify.
  474. * @return object $menu_item The menu item with standard menu item properties.
  475. */
  476. function wp_setup_nav_menu_item( $menu_item ) {
  477. if ( isset( $menu_item->post_type ) ) {
  478. if ( 'nav_menu_item' == $menu_item->post_type ) {
  479. $menu_item->db_id = (int) $menu_item->ID;
  480. $menu_item->menu_item_parent = empty( $menu_item->menu_item_parent ) ? get_post_meta( $menu_item->ID, '_menu_item_menu_item_parent', true ) : $menu_item->menu_item_parent;
  481. $menu_item->object_id = empty( $menu_item->object_id ) ? get_post_meta( $menu_item->ID, '_menu_item_object_id', true ) : $menu_item->object_id;
  482. $menu_item->object = empty( $menu_item->object ) ? get_post_meta( $menu_item->ID, '_menu_item_object', true ) : $menu_item->object;
  483. $menu_item->type = empty( $menu_item->type ) ? get_post_meta( $menu_item->ID, '_menu_item_type', true ) : $menu_item->type;
  484. if ( 'post_type' == $menu_item->type ) {
  485. $object = get_post_type_object( $menu_item->object );
  486. if ( $object ) {
  487. $menu_item->type_label = $object->labels->singular_name;
  488. } else {
  489. $menu_item->type_label = $menu_item->object;
  490. $menu_item->_invalid = true;
  491. }
  492. $menu_item->url = get_permalink( $menu_item->object_id );
  493. $original_object = get_post( $menu_item->object_id );
  494. $original_title = $original_object->post_title;
  495. $menu_item->title = '' == $menu_item->post_title ? $original_title : $menu_item->post_title;
  496. } elseif ( 'taxonomy' == $menu_item->type ) {
  497. $object = get_taxonomy( $menu_item->object );
  498. if ( $object ) {
  499. $menu_item->type_label = $object->labels->singular_name;
  500. } else {
  501. $menu_item->type_label = $menu_item->object;
  502. $menu_item->_invalid = true;
  503. }
  504. $term_url = get_term_link( (int) $menu_item->object_id, $menu_item->object );
  505. $menu_item->url = !is_wp_error( $term_url ) ? $term_url : '';
  506. $original_title = get_term_field( 'name', $menu_item->object_id, $menu_item->object, 'raw' );
  507. if ( is_wp_error( $original_title ) )
  508. $original_title = false;
  509. $menu_item->title = '' == $menu_item->post_title ? $original_title : $menu_item->post_title;
  510. } else {
  511. $menu_item->type_label = __('Custom');
  512. $menu_item->title = $menu_item->post_title;
  513. $menu_item->url = empty( $menu_item->url ) ? get_post_meta( $menu_item->ID, '_menu_item_url', true ) : $menu_item->url;
  514. }
  515. $menu_item->target = empty( $menu_item->target ) ? get_post_meta( $menu_item->ID, '_menu_item_target', true ) : $menu_item->target;
  516. $menu_item->attr_title = empty( $menu_item->attr_title ) ? apply_filters( 'nav_menu_attr_title', $menu_item->post_excerpt ) : $menu_item->attr_title;
  517. if ( empty( $menu_item->description ) )
  518. $menu_item->description = apply_filters( 'nav_menu_description', wp_trim_words( $menu_item->post_content, 200 ) );
  519. $menu_item->classes = empty( $menu_item->classes ) ? (array) get_post_meta( $menu_item->ID, '_menu_item_classes', true ) : $menu_item->classes;
  520. $menu_item->xfn = empty( $menu_item->xfn ) ? get_post_meta( $menu_item->ID, '_menu_item_xfn', true ) : $menu_item->xfn;
  521. } else {
  522. $menu_item->db_id = 0;
  523. $menu_item->menu_item_parent = 0;
  524. $menu_item->object_id = (int) $menu_item->ID;
  525. $menu_item->type = 'post_type';
  526. $object = get_post_type_object( $menu_item->post_type );
  527. $menu_item->object = $object->name;
  528. $menu_item->type_label = $object->labels->singular_name;
  529. $menu_item->title = $menu_item->post_title;
  530. $menu_item->url = get_permalink( $menu_item->ID );
  531. $menu_item->target = '';
  532. $menu_item->attr_title = apply_filters( 'nav_menu_attr_title', '' );
  533. $menu_item->description = apply_filters( 'nav_menu_description', '' );
  534. $menu_item->classes = array();
  535. $menu_item->xfn = '';
  536. }
  537. } elseif ( isset( $menu_item->taxonomy ) ) {
  538. $menu_item->ID = $menu_item->term_id;
  539. $menu_item->db_id = 0;
  540. $menu_item->menu_item_parent = 0;
  541. $menu_item->object_id = (int) $menu_item->term_id;
  542. $menu_item->post_parent = (int) $menu_item->parent;
  543. $menu_item->type = 'taxonomy';
  544. $object = get_taxonomy( $menu_item->taxonomy );
  545. $menu_item->object = $object->name;
  546. $menu_item->type_label = $object->labels->singular_name;
  547. $menu_item->title = $menu_item->name;
  548. $menu_item->url = get_term_link( $menu_item, $menu_item->taxonomy );
  549. $menu_item->target = '';
  550. $menu_item->attr_title = '';
  551. $menu_item->description = get_term_field( 'description', $menu_item->term_id, $menu_item->taxonomy );
  552. $menu_item->classes = array();
  553. $menu_item->xfn = '';
  554. }
  555. return apply_filters( 'wp_setup_nav_menu_item', $menu_item );
  556. }
  557. /**
  558. * Get the menu items associated with a particular object.
  559. *
  560. * @since 3.0.0
  561. *
  562. * @param int $object_id The ID of the original object.
  563. * @param string $object_type The type of object, such as "taxonomy" or "post_type."
  564. * @return array The array of menu item IDs; empty array if none;
  565. */
  566. function wp_get_associated_nav_menu_items( $object_id = 0, $object_type = 'post_type' ) {
  567. $object_id = (int) $object_id;
  568. $menu_item_ids = array();
  569. $query = new WP_Query;
  570. $menu_items = $query->query(
  571. array(
  572. 'meta_key' => '_menu_item_object_id',
  573. 'meta_value' => $object_id,
  574. 'post_status' => 'any',
  575. 'post_type' => 'nav_menu_item',
  576. 'posts_per_page' => -1,
  577. )
  578. );
  579. foreach( (array) $menu_items as $menu_item ) {
  580. if ( isset( $menu_item->ID ) && is_nav_menu_item( $menu_item->ID ) ) {
  581. if ( get_post_meta( $menu_item->ID, '_menu_item_type', true ) != $object_type )
  582. continue;
  583. $menu_item_ids[] = (int) $menu_item->ID;
  584. }
  585. }
  586. return array_unique( $menu_item_ids );
  587. }
  588. /**
  589. * Callback for handling a menu item when its original object is deleted.
  590. *
  591. * @since 3.0.0
  592. * @access private
  593. *
  594. * @param int $object_id The ID of the original object being trashed.
  595. *
  596. */
  597. function _wp_delete_post_menu_item( $object_id = 0 ) {
  598. $object_id = (int) $object_id;
  599. $menu_item_ids = wp_get_associated_nav_menu_items( $object_id, 'post_type' );
  600. foreach( (array) $menu_item_ids as $menu_item_id ) {
  601. wp_delete_post( $menu_item_id, true );
  602. }
  603. }
  604. /**
  605. * Callback for handling a menu item when its original object is deleted.
  606. *
  607. * @since 3.0.0
  608. * @access private
  609. *
  610. * @param int $object_id The ID of the original object being trashed.
  611. *
  612. */
  613. function _wp_delete_tax_menu_item( $object_id = 0 ) {
  614. $object_id = (int) $object_id;
  615. $menu_item_ids = wp_get_associated_nav_menu_items( $object_id, 'taxonomy' );
  616. foreach( (array) $menu_item_ids as $menu_item_id ) {
  617. wp_delete_post( $menu_item_id, true );
  618. }
  619. }
  620. /**
  621. * Automatically add newly published page objects to menus with that as an option.
  622. *
  623. * @since 3.0.0
  624. * @access private
  625. *
  626. * @param string $new_status The new status of the post object.
  627. * @param string $old_status The old status of the post object.
  628. * @param object $post The post object being transitioned from one status to another.
  629. * @return void
  630. */
  631. function _wp_auto_add_pages_to_menu( $new_status, $old_status, $post ) {
  632. if ( 'publish' != $new_status || 'publish' == $old_status || 'page' != $post->post_type )
  633. return;
  634. if ( ! empty( $post->post_parent ) )
  635. return;
  636. $auto_add = get_option( 'nav_menu_options' );
  637. if ( empty( $auto_add ) || ! is_array( $auto_add ) || ! isset( $auto_add['auto_add'] ) )
  638. return;
  639. $auto_add = $auto_add['auto_add'];
  640. if ( empty( $auto_add ) || ! is_array( $auto_add ) )
  641. return;
  642. $args = array(
  643. 'menu-item-object-id' => $post->ID,
  644. 'menu-item-object' => $post->post_type,
  645. 'menu-item-type' => 'post_type',
  646. 'menu-item-status' => 'publish',
  647. );
  648. foreach ( $auto_add as $menu_id ) {
  649. $items = wp_get_nav_menu_items( $menu_id, array( 'post_status' => 'publish,draft' ) );
  650. if ( ! is_array( $items ) )
  651. continue;
  652. foreach ( $items as $item ) {
  653. if ( $post->ID == $item->object_id )
  654. continue 2;
  655. }
  656. wp_update_nav_menu_item( $menu_id, 0, $args );
  657. }
  658. }
  659. ?>