[ Index ]

PHP Cross Reference of WordPress

title

Body

[close]

/wp-includes/ -> class-wp-customize-nav-menus.php (source)

   1  <?php
   2  /**
   3   * WordPress Customize Nav Menus classes
   4   *
   5   * @package WordPress
   6   * @subpackage Customize
   7   * @since 4.3.0
   8   */
   9  
  10  /**
  11   * Customize Nav Menus class.
  12   *
  13   * Implements menu management in the Customizer.
  14   *
  15   * @since 4.3.0
  16   *
  17   * @see WP_Customize_Manager
  18   */
  19  final class WP_Customize_Nav_Menus {
  20  
  21      /**
  22       * WP_Customize_Manager instance.
  23       *
  24       * @since 4.3.0
  25       * @var WP_Customize_Manager
  26       */
  27      public $manager;
  28  
  29      /**
  30       * Original nav menu locations before the theme was switched.
  31       *
  32       * @since 4.9.0
  33       * @var array
  34       */
  35      protected $original_nav_menu_locations;
  36  
  37      /**
  38       * Constructor.
  39       *
  40       * @since 4.3.0
  41       *
  42       * @param WP_Customize_Manager $manager Customizer bootstrap instance.
  43       */
  44  	public function __construct( $manager ) {
  45          $this->manager                     = $manager;
  46          $this->original_nav_menu_locations = get_nav_menu_locations();
  47  
  48          // See https://github.com/xwp/wp-customize-snapshots/blob/962586659688a5b1fd9ae93618b7ce2d4e7a421c/php/class-customize-snapshot-manager.php#L469-L499
  49          add_action( 'customize_register', array( $this, 'customize_register' ), 11 );
  50          add_filter( 'customize_dynamic_setting_args', array( $this, 'filter_dynamic_setting_args' ), 10, 2 );
  51          add_filter( 'customize_dynamic_setting_class', array( $this, 'filter_dynamic_setting_class' ), 10, 3 );
  52          add_action( 'customize_save_nav_menus_created_posts', array( $this, 'save_nav_menus_created_posts' ) );
  53  
  54          // Skip remaining hooks when the user can't manage nav menus anyway.
  55          if ( ! current_user_can( 'edit_theme_options' ) ) {
  56              return;
  57          }
  58  
  59          add_filter( 'customize_refresh_nonces', array( $this, 'filter_nonces' ) );
  60          add_action( 'wp_ajax_load-available-menu-items-customizer', array( $this, 'ajax_load_available_items' ) );
  61          add_action( 'wp_ajax_search-available-menu-items-customizer', array( $this, 'ajax_search_available_items' ) );
  62          add_action( 'wp_ajax_customize-nav-menus-insert-auto-draft', array( $this, 'ajax_insert_auto_draft_post' ) );
  63          add_action( 'customize_controls_enqueue_scripts', array( $this, 'enqueue_scripts' ) );
  64          add_action( 'customize_controls_print_footer_scripts', array( $this, 'print_templates' ) );
  65          add_action( 'customize_controls_print_footer_scripts', array( $this, 'available_items_template' ) );
  66          add_action( 'customize_preview_init', array( $this, 'customize_preview_init' ) );
  67          add_action( 'customize_preview_init', array( $this, 'make_auto_draft_status_previewable' ) );
  68  
  69          // Selective Refresh partials.
  70          add_filter( 'customize_dynamic_partial_args', array( $this, 'customize_dynamic_partial_args' ), 10, 2 );
  71      }
  72  
  73      /**
  74       * Adds a nonce for customizing menus.
  75       *
  76       * @since 4.5.0
  77       *
  78       * @param string[] $nonces Array of nonces.
  79       * @return string[] Modified array of nonces.
  80       */
  81  	public function filter_nonces( $nonces ) {
  82          $nonces['customize-menus'] = wp_create_nonce( 'customize-menus' );
  83          return $nonces;
  84      }
  85  
  86      /**
  87       * Ajax handler for loading available menu items.
  88       *
  89       * @since 4.3.0
  90       */
  91  	public function ajax_load_available_items() {
  92          check_ajax_referer( 'customize-menus', 'customize-menus-nonce' );
  93  
  94          if ( ! current_user_can( 'edit_theme_options' ) ) {
  95              wp_die( -1 );
  96          }
  97  
  98          $all_items  = array();
  99          $item_types = array();
 100          if ( isset( $_POST['item_types'] ) && is_array( $_POST['item_types'] ) ) {
 101              $item_types = wp_unslash( $_POST['item_types'] );
 102          } elseif ( isset( $_POST['type'] ) && isset( $_POST['object'] ) ) { // Back compat.
 103              $item_types[] = array(
 104                  'type'   => wp_unslash( $_POST['type'] ),
 105                  'object' => wp_unslash( $_POST['object'] ),
 106                  'page'   => empty( $_POST['page'] ) ? 0 : absint( $_POST['page'] ),
 107              );
 108          } else {
 109              wp_send_json_error( 'nav_menus_missing_type_or_object_parameter' );
 110          }
 111  
 112          foreach ( $item_types as $item_type ) {
 113              if ( empty( $item_type['type'] ) || empty( $item_type['object'] ) ) {
 114                  wp_send_json_error( 'nav_menus_missing_type_or_object_parameter' );
 115              }
 116              $type   = sanitize_key( $item_type['type'] );
 117              $object = sanitize_key( $item_type['object'] );
 118              $page   = empty( $item_type['page'] ) ? 0 : absint( $item_type['page'] );
 119              $items  = $this->load_available_items_query( $type, $object, $page );
 120              if ( is_wp_error( $items ) ) {
 121                  wp_send_json_error( $items->get_error_code() );
 122              }
 123              $all_items[ $item_type['type'] . ':' . $item_type['object'] ] = $items;
 124          }
 125  
 126          wp_send_json_success( array( 'items' => $all_items ) );
 127      }
 128  
 129      /**
 130       * Performs the post_type and taxonomy queries for loading available menu items.
 131       *
 132       * @since 4.3.0
 133       *
 134       * @param string $type   Optional. Accepts any custom object type and has built-in support for
 135       *                         'post_type' and 'taxonomy'. Default is 'post_type'.
 136       * @param string $object Optional. Accepts any registered taxonomy or post type name. Default is 'page'.
 137       * @param int    $page   Optional. The page number used to generate the query offset. Default is '0'.
 138       * @return array|WP_Error An array of menu items on success, a WP_Error object on failure.
 139       */
 140  	public function load_available_items_query( $type = 'post_type', $object = 'page', $page = 0 ) {
 141          $items = array();
 142  
 143          if ( 'post_type' === $type ) {
 144              $post_type = get_post_type_object( $object );
 145              if ( ! $post_type ) {
 146                  return new WP_Error( 'nav_menus_invalid_post_type' );
 147              }
 148  
 149              /*
 150               * If we're dealing with pages, let's prioritize the Front Page,
 151               * Posts Page and Privacy Policy Page at the top of the list.
 152               */
 153              $important_pages   = array();
 154              $suppress_page_ids = array();
 155              if ( 0 === $page && 'page' === $object ) {
 156                  // Insert Front Page or custom "Home" link.
 157                  $front_page = 'page' === get_option( 'show_on_front' ) ? (int) get_option( 'page_on_front' ) : 0;
 158                  if ( ! empty( $front_page ) ) {
 159                      $front_page_obj      = get_post( $front_page );
 160                      $important_pages[]   = $front_page_obj;
 161                      $suppress_page_ids[] = $front_page_obj->ID;
 162                  } else {
 163                      // Add "Home" link. Treat as a page, but switch to custom on add.
 164                      $items[] = array(
 165                          'id'         => 'home',
 166                          'title'      => _x( 'Home', 'nav menu home label' ),
 167                          'type'       => 'custom',
 168                          'type_label' => __( 'Custom Link' ),
 169                          'object'     => '',
 170                          'url'        => home_url(),
 171                      );
 172                  }
 173  
 174                  // Insert Posts Page.
 175                  $posts_page = 'page' === get_option( 'show_on_front' ) ? (int) get_option( 'page_for_posts' ) : 0;
 176                  if ( ! empty( $posts_page ) ) {
 177                      $posts_page_obj      = get_post( $posts_page );
 178                      $important_pages[]   = $posts_page_obj;
 179                      $suppress_page_ids[] = $posts_page_obj->ID;
 180                  }
 181  
 182                  // Insert Privacy Policy Page.
 183                  $privacy_policy_page_id = (int) get_option( 'wp_page_for_privacy_policy' );
 184                  if ( ! empty( $privacy_policy_page_id ) ) {
 185                      $privacy_policy_page = get_post( $privacy_policy_page_id );
 186                      if ( $privacy_policy_page instanceof WP_Post && 'publish' === $privacy_policy_page->post_status ) {
 187                          $important_pages[]   = $privacy_policy_page;
 188                          $suppress_page_ids[] = $privacy_policy_page->ID;
 189                      }
 190                  }
 191              } elseif ( 'post' !== $object && 0 === $page && $post_type->has_archive ) {
 192                  // Add a post type archive link.
 193                  $items[] = array(
 194                      'id'         => $object . '-archive',
 195                      'title'      => $post_type->labels->archives,
 196                      'type'       => 'post_type_archive',
 197                      'type_label' => __( 'Post Type Archive' ),
 198                      'object'     => $object,
 199                      'url'        => get_post_type_archive_link( $object ),
 200                  );
 201              }
 202  
 203              // Prepend posts with nav_menus_created_posts on first page.
 204              $posts = array();
 205              if ( 0 === $page && $this->manager->get_setting( 'nav_menus_created_posts' ) ) {
 206                  foreach ( $this->manager->get_setting( 'nav_menus_created_posts' )->value() as $post_id ) {
 207                      $auto_draft_post = get_post( $post_id );
 208                      if ( $post_type->name === $auto_draft_post->post_type ) {
 209                          $posts[] = $auto_draft_post;
 210                      }
 211                  }
 212              }
 213  
 214              $args = array(
 215                  'numberposts' => 10,
 216                  'offset'      => 10 * $page,
 217                  'orderby'     => 'date',
 218                  'order'       => 'DESC',
 219                  'post_type'   => $object,
 220              );
 221  
 222              // Add suppression array to arguments for get_posts.
 223              if ( ! empty( $suppress_page_ids ) ) {
 224                  $args['post__not_in'] = $suppress_page_ids;
 225              }
 226  
 227              $posts = array_merge(
 228                  $posts,
 229                  $important_pages,
 230                  get_posts( $args )
 231              );
 232  
 233              foreach ( $posts as $post ) {
 234                  $post_title = $post->post_title;
 235                  if ( '' === $post_title ) {
 236                      /* translators: %d: ID of a post. */
 237                      $post_title = sprintf( __( '#%d (no title)' ), $post->ID );
 238                  }
 239  
 240                  $post_type_label = get_post_type_object( $post->post_type )->labels->singular_name;
 241                  $post_states     = get_post_states( $post );
 242                  if ( ! empty( $post_states ) ) {
 243                      $post_type_label = implode( ',', $post_states );
 244                  }
 245  
 246                  $items[] = array(
 247                      'id'         => "post-{$post->ID}",
 248                      'title'      => html_entity_decode( $post_title, ENT_QUOTES, get_bloginfo( 'charset' ) ),
 249                      'type'       => 'post_type',
 250                      'type_label' => $post_type_label,
 251                      'object'     => $post->post_type,
 252                      'object_id'  => (int) $post->ID,
 253                      'url'        => get_permalink( (int) $post->ID ),
 254                  );
 255              }
 256          } elseif ( 'taxonomy' === $type ) {
 257              $terms = get_terms(
 258                  array(
 259                      'taxonomy'     => $object,
 260                      'child_of'     => 0,
 261                      'exclude'      => '',
 262                      'hide_empty'   => false,
 263                      'hierarchical' => 1,
 264                      'include'      => '',
 265                      'number'       => 10,
 266                      'offset'       => 10 * $page,
 267                      'order'        => 'DESC',
 268                      'orderby'      => 'count',
 269                      'pad_counts'   => false,
 270                  )
 271              );
 272  
 273              if ( is_wp_error( $terms ) ) {
 274                  return $terms;
 275              }
 276  
 277              foreach ( $terms as $term ) {
 278                  $items[] = array(
 279                      'id'         => "term-{$term->term_id}",
 280                      'title'      => html_entity_decode( $term->name, ENT_QUOTES, get_bloginfo( 'charset' ) ),
 281                      'type'       => 'taxonomy',
 282                      'type_label' => get_taxonomy( $term->taxonomy )->labels->singular_name,
 283                      'object'     => $term->taxonomy,
 284                      'object_id'  => (int) $term->term_id,
 285                      'url'        => get_term_link( (int) $term->term_id, $term->taxonomy ),
 286                  );
 287              }
 288          }
 289  
 290          /**
 291           * Filters the available menu items.
 292           *
 293           * @since 4.3.0
 294           *
 295           * @param array  $items  The array of menu items.
 296           * @param string $type   The object type.
 297           * @param string $object The object name.
 298           * @param int    $page   The current page number.
 299           */
 300          $items = apply_filters( 'customize_nav_menu_available_items', $items, $type, $object, $page );
 301  
 302          return $items;
 303      }
 304  
 305      /**
 306       * Ajax handler for searching available menu items.
 307       *
 308       * @since 4.3.0
 309       */
 310  	public function ajax_search_available_items() {
 311          check_ajax_referer( 'customize-menus', 'customize-menus-nonce' );
 312  
 313          if ( ! current_user_can( 'edit_theme_options' ) ) {
 314              wp_die( -1 );
 315          }
 316  
 317          if ( empty( $_POST['search'] ) ) {
 318              wp_send_json_error( 'nav_menus_missing_search_parameter' );
 319          }
 320  
 321          $p = isset( $_POST['page'] ) ? absint( $_POST['page'] ) : 0;
 322          if ( $p < 1 ) {
 323              $p = 1;
 324          }
 325  
 326          $s     = sanitize_text_field( wp_unslash( $_POST['search'] ) );
 327          $items = $this->search_available_items_query(
 328              array(
 329                  'pagenum' => $p,
 330                  's'       => $s,
 331              )
 332          );
 333  
 334          if ( empty( $items ) ) {
 335              wp_send_json_error( array( 'message' => __( 'No results found.' ) ) );
 336          } else {
 337              wp_send_json_success( array( 'items' => $items ) );
 338          }
 339      }
 340  
 341      /**
 342       * Performs post queries for available-item searching.
 343       *
 344       * Based on WP_Editor::wp_link_query().
 345       *
 346       * @since 4.3.0
 347       *
 348       * @param array $args Optional. Accepts 'pagenum' and 's' (search) arguments.
 349       * @return array Menu items.
 350       */
 351  	public function search_available_items_query( $args = array() ) {
 352          $items = array();
 353  
 354          $post_type_objects = get_post_types( array( 'show_in_nav_menus' => true ), 'objects' );
 355          $query             = array(
 356              'post_type'              => array_keys( $post_type_objects ),
 357              'suppress_filters'       => true,
 358              'update_post_term_cache' => false,
 359              'update_post_meta_cache' => false,
 360              'post_status'            => 'publish',
 361              'posts_per_page'         => 20,
 362          );
 363  
 364          $args['pagenum'] = isset( $args['pagenum'] ) ? absint( $args['pagenum'] ) : 1;
 365          $query['offset'] = $args['pagenum'] > 1 ? $query['posts_per_page'] * ( $args['pagenum'] - 1 ) : 0;
 366  
 367          if ( isset( $args['s'] ) ) {
 368              $query['s'] = $args['s'];
 369          }
 370  
 371          $posts = array();
 372  
 373          // Prepend list of posts with nav_menus_created_posts search results on first page.
 374          $nav_menus_created_posts_setting = $this->manager->get_setting( 'nav_menus_created_posts' );
 375          if ( 1 === $args['pagenum'] && $nav_menus_created_posts_setting && count( $nav_menus_created_posts_setting->value() ) > 0 ) {
 376              $stub_post_query = new WP_Query(
 377                  array_merge(
 378                      $query,
 379                      array(
 380                          'post_status'    => 'auto-draft',
 381                          'post__in'       => $nav_menus_created_posts_setting->value(),
 382                          'posts_per_page' => -1,
 383                      )
 384                  )
 385              );
 386              $posts           = array_merge( $posts, $stub_post_query->posts );
 387          }
 388  
 389          // Query posts.
 390          $get_posts = new WP_Query( $query );
 391          $posts     = array_merge( $posts, $get_posts->posts );
 392  
 393          // Create items for posts.
 394          foreach ( $posts as $post ) {
 395              $post_title = $post->post_title;
 396              if ( '' === $post_title ) {
 397                  /* translators: %d: ID of a post. */
 398                  $post_title = sprintf( __( '#%d (no title)' ), $post->ID );
 399              }
 400  
 401              $post_type_label = $post_type_objects[ $post->post_type ]->labels->singular_name;
 402              $post_states     = get_post_states( $post );
 403              if ( ! empty( $post_states ) ) {
 404                  $post_type_label = implode( ',', $post_states );
 405              }
 406  
 407              $items[] = array(
 408                  'id'         => 'post-' . $post->ID,
 409                  'title'      => html_entity_decode( $post_title, ENT_QUOTES, get_bloginfo( 'charset' ) ),
 410                  'type'       => 'post_type',
 411                  'type_label' => $post_type_label,
 412                  'object'     => $post->post_type,
 413                  'object_id'  => (int) $post->ID,
 414                  'url'        => get_permalink( (int) $post->ID ),
 415              );
 416          }
 417  
 418          // Query taxonomy terms.
 419          $taxonomies = get_taxonomies( array( 'show_in_nav_menus' => true ), 'names' );
 420          $terms      = get_terms(
 421              array(
 422                  'taxonomies' => $taxonomies,
 423                  'name__like' => $args['s'],
 424                  'number'     => 20,
 425                  'hide_empty' => false,
 426                  'offset'     => 20 * ( $args['pagenum'] - 1 ),
 427              )
 428          );
 429  
 430          // Check if any taxonomies were found.
 431          if ( ! empty( $terms ) ) {
 432              foreach ( $terms as $term ) {
 433                  $items[] = array(
 434                      'id'         => 'term-' . $term->term_id,
 435                      'title'      => html_entity_decode( $term->name, ENT_QUOTES, get_bloginfo( 'charset' ) ),
 436                      'type'       => 'taxonomy',
 437                      'type_label' => get_taxonomy( $term->taxonomy )->labels->singular_name,
 438                      'object'     => $term->taxonomy,
 439                      'object_id'  => (int) $term->term_id,
 440                      'url'        => get_term_link( (int) $term->term_id, $term->taxonomy ),
 441                  );
 442              }
 443          }
 444  
 445          // Add "Home" link if search term matches. Treat as a page, but switch to custom on add.
 446          if ( isset( $args['s'] ) ) {
 447              // Only insert custom "Home" link if there's no Front Page
 448              $front_page = 'page' === get_option( 'show_on_front' ) ? (int) get_option( 'page_on_front' ) : 0;
 449              if ( empty( $front_page ) ) {
 450                  $title   = _x( 'Home', 'nav menu home label' );
 451                  $matches = function_exists( 'mb_stripos' ) ? false !== mb_stripos( $title, $args['s'] ) : false !== stripos( $title, $args['s'] );
 452                  if ( $matches ) {
 453                      $items[] = array(
 454                          'id'         => 'home',
 455                          'title'      => $title,
 456                          'type'       => 'custom',
 457                          'type_label' => __( 'Custom Link' ),
 458                          'object'     => '',
 459                          'url'        => home_url(),
 460                      );
 461                  }
 462              }
 463          }
 464  
 465          /**
 466           * Filters the available menu items during a search request.
 467           *
 468           * @since 4.5.0
 469           *
 470           * @param array $items The array of menu items.
 471           * @param array $args  Includes 'pagenum' and 's' (search) arguments.
 472           */
 473          $items = apply_filters( 'customize_nav_menu_searched_items', $items, $args );
 474  
 475          return $items;
 476      }
 477  
 478      /**
 479       * Enqueue scripts and styles for Customizer pane.
 480       *
 481       * @since 4.3.0
 482       */
 483  	public function enqueue_scripts() {
 484          wp_enqueue_style( 'customize-nav-menus' );
 485          wp_enqueue_script( 'customize-nav-menus' );
 486  
 487          $temp_nav_menu_setting      = new WP_Customize_Nav_Menu_Setting( $this->manager, 'nav_menu[-1]' );
 488          $temp_nav_menu_item_setting = new WP_Customize_Nav_Menu_Item_Setting( $this->manager, 'nav_menu_item[-1]' );
 489  
 490          $num_locations = count( get_registered_nav_menus() );
 491  
 492          if ( 1 === $num_locations ) {
 493              $locations_description = __( 'Your theme can display menus in one location.' );
 494          } else {
 495              /* translators: %s: Number of menu locations. */
 496              $locations_description = sprintf( _n( 'Your theme can display menus in %s location.', 'Your theme can display menus in %s locations.', $num_locations ), number_format_i18n( $num_locations ) );
 497          }
 498  
 499          // Pass data to JS.
 500          $settings = array(
 501              'allMenus'                 => wp_get_nav_menus(),
 502              'itemTypes'                => $this->available_item_types(),
 503              'l10n'                     => array(
 504                  'untitled'               => _x( '(no label)', 'missing menu item navigation label' ),
 505                  'unnamed'                => _x( '(unnamed)', 'Missing menu name.' ),
 506                  'custom_label'           => __( 'Custom Link' ),
 507                  'page_label'             => get_post_type_object( 'page' )->labels->singular_name,
 508                  /* translators: %s: Menu location. */
 509                  'menuLocation'           => _x( '(Currently set to: %s)', 'menu' ),
 510                  'locationsTitle'         => 1 === $num_locations ? __( 'Menu Location' ) : __( 'Menu Locations' ),
 511                  'locationsDescription'   => $locations_description,
 512                  'menuNameLabel'          => __( 'Menu Name' ),
 513                  'newMenuNameDescription' => __( 'If your theme has multiple menus, giving them clear names will help you manage them.' ),
 514                  'itemAdded'              => __( 'Menu item added' ),
 515                  'itemDeleted'            => __( 'Menu item deleted' ),
 516                  'menuAdded'              => __( 'Menu created' ),
 517                  'menuDeleted'            => __( 'Menu deleted' ),
 518                  'movedUp'                => __( 'Menu item moved up' ),
 519                  'movedDown'              => __( 'Menu item moved down' ),
 520                  'movedLeft'              => __( 'Menu item moved out of submenu' ),
 521                  'movedRight'             => __( 'Menu item is now a sub-item' ),
 522                  /* translators: &#9656; is the unicode right-pointing triangle. %s: Section title in the Customizer. */
 523                  'customizingMenus'       => sprintf( __( 'Customizing &#9656; %s' ), esc_html( $this->manager->get_panel( 'nav_menus' )->title ) ),
 524                  /* translators: %s: Title of an invalid menu item. */
 525                  'invalidTitleTpl'        => __( '%s (Invalid)' ),
 526                  /* translators: %s: Title of a menu item in draft status. */
 527                  'pendingTitleTpl'        => __( '%s (Pending)' ),
 528                  /* translators: %d: Number of menu items found. */
 529                  'itemsFound'             => __( 'Number of items found: %d' ),
 530                  /* translators: %d: Number of additional menu items found. */
 531                  'itemsFoundMore'         => __( 'Additional items found: %d' ),
 532                  'itemsLoadingMore'       => __( 'Loading more results... please wait.' ),
 533                  'reorderModeOn'          => __( 'Reorder mode enabled' ),
 534                  'reorderModeOff'         => __( 'Reorder mode closed' ),
 535                  'reorderLabelOn'         => esc_attr__( 'Reorder menu items' ),
 536                  'reorderLabelOff'        => esc_attr__( 'Close reorder mode' ),
 537              ),
 538              'settingTransport'         => 'postMessage',
 539              'phpIntMax'                => PHP_INT_MAX,
 540              'defaultSettingValues'     => array(
 541                  'nav_menu'      => $temp_nav_menu_setting->default,
 542                  'nav_menu_item' => $temp_nav_menu_item_setting->default,
 543              ),
 544              'locationSlugMappedToName' => get_registered_nav_menus(),
 545          );
 546  
 547          $data = sprintf( 'var _wpCustomizeNavMenusSettings = %s;', wp_json_encode( $settings ) );
 548          wp_scripts()->add_data( 'customize-nav-menus', 'data', $data );
 549  
 550          // This is copied from nav-menus.php, and it has an unfortunate object name of `menus`.
 551          $nav_menus_l10n = array(
 552              'oneThemeLocationNoMenus' => null,
 553              'moveUp'                  => __( 'Move up one' ),
 554              'moveDown'                => __( 'Move down one' ),
 555              'moveToTop'               => __( 'Move to the top' ),
 556              /* translators: %s: Previous item name. */
 557              'moveUnder'               => __( 'Move under %s' ),
 558              /* translators: %s: Previous item name. */
 559              'moveOutFrom'             => __( 'Move out from under %s' ),
 560              /* translators: %s: Previous item name. */
 561              'under'                   => __( 'Under %s' ),
 562              /* translators: %s: Previous item name. */
 563              'outFrom'                 => __( 'Out from under %s' ),
 564              /* translators: 1: Item name, 2: Item position, 3: Total number of items. */
 565              'menuFocus'               => __( '%1$s. Menu item %2$d of %3$d.' ),
 566              /* translators: 1: Item name, 2: Item position, 3: Parent item name. */
 567              'subMenuFocus'            => __( '%1$s. Sub item number %2$d under %3$s.' ),
 568          );
 569          wp_localize_script( 'nav-menu', 'menus', $nav_menus_l10n );
 570      }
 571  
 572      /**
 573       * Filters a dynamic setting's constructor args.
 574       *
 575       * For a dynamic setting to be registered, this filter must be employed
 576       * to override the default false value with an array of args to pass to
 577       * the WP_Customize_Setting constructor.
 578       *
 579       * @since 4.3.0
 580       *
 581       * @param false|array $setting_args The arguments to the WP_Customize_Setting constructor.
 582       * @param string      $setting_id   ID for dynamic setting, usually coming from `$_POST['customized']`.
 583       * @return array|false
 584       */
 585  	public function filter_dynamic_setting_args( $setting_args, $setting_id ) {
 586          if ( preg_match( WP_Customize_Nav_Menu_Setting::ID_PATTERN, $setting_id ) ) {
 587              $setting_args = array(
 588                  'type'      => WP_Customize_Nav_Menu_Setting::TYPE,
 589                  'transport' => 'postMessage',
 590              );
 591          } elseif ( preg_match( WP_Customize_Nav_Menu_Item_Setting::ID_PATTERN, $setting_id ) ) {
 592              $setting_args = array(
 593                  'type'      => WP_Customize_Nav_Menu_Item_Setting::TYPE,
 594                  'transport' => 'postMessage',
 595              );
 596          }
 597          return $setting_args;
 598      }
 599  
 600      /**
 601       * Allow non-statically created settings to be constructed with custom WP_Customize_Setting subclass.
 602       *
 603       * @since 4.3.0
 604       *
 605       * @param string $setting_class WP_Customize_Setting or a subclass.
 606       * @param string $setting_id    ID for dynamic setting, usually coming from `$_POST['customized']`.
 607       * @param array  $setting_args  WP_Customize_Setting or a subclass.
 608       * @return string
 609       */
 610  	public function filter_dynamic_setting_class( $setting_class, $setting_id, $setting_args ) {
 611          unset( $setting_id );
 612  
 613          if ( ! empty( $setting_args['type'] ) && WP_Customize_Nav_Menu_Setting::TYPE === $setting_args['type'] ) {
 614              $setting_class = 'WP_Customize_Nav_Menu_Setting';
 615          } elseif ( ! empty( $setting_args['type'] ) && WP_Customize_Nav_Menu_Item_Setting::TYPE === $setting_args['type'] ) {
 616              $setting_class = 'WP_Customize_Nav_Menu_Item_Setting';
 617          }
 618          return $setting_class;
 619      }
 620  
 621      /**
 622       * Add the customizer settings and controls.
 623       *
 624       * @since 4.3.0
 625       */
 626  	public function customize_register() {
 627          $changeset = $this->manager->unsanitized_post_values();
 628  
 629          // Preview settings for nav menus early so that the sections and controls will be added properly.
 630          $nav_menus_setting_ids = array();
 631          foreach ( array_keys( $changeset ) as $setting_id ) {
 632              if ( preg_match( '/^(nav_menu_locations|nav_menu|nav_menu_item)\[/', $setting_id ) ) {
 633                  $nav_menus_setting_ids[] = $setting_id;
 634              }
 635          }
 636          $settings = $this->manager->add_dynamic_settings( $nav_menus_setting_ids );
 637          if ( $this->manager->settings_previewed() ) {
 638              foreach ( $settings as $setting ) {
 639                  $setting->preview();
 640              }
 641          }
 642  
 643          // Require JS-rendered control types.
 644          $this->manager->register_panel_type( 'WP_Customize_Nav_Menus_Panel' );
 645          $this->manager->register_control_type( 'WP_Customize_Nav_Menu_Control' );
 646          $this->manager->register_control_type( 'WP_Customize_Nav_Menu_Name_Control' );
 647          $this->manager->register_control_type( 'WP_Customize_Nav_Menu_Locations_Control' );
 648          $this->manager->register_control_type( 'WP_Customize_Nav_Menu_Auto_Add_Control' );
 649          $this->manager->register_control_type( 'WP_Customize_Nav_Menu_Item_Control' );
 650  
 651          // Create a panel for Menus.
 652          $description = '<p>' . __( 'This panel is used for managing navigation menus for content you have already published on your site. You can create menus and add items for existing content such as pages, posts, categories, tags, formats, or custom links.' ) . '</p>';
 653          if ( current_theme_supports( 'widgets' ) ) {
 654              $description .= '<p>' . sprintf(
 655                  /* translators: %s: URL to the Widgets panel of the Customizer. */
 656                  __( 'Menus can be displayed in locations defined by your theme or in <a href="%s">widget areas</a> by adding a &#8220;Navigation Menu&#8221; widget.' ),
 657                  "javascript:wp.customize.panel( 'widgets' ).focus();"
 658              ) . '</p>';
 659          } else {
 660              $description .= '<p>' . __( 'Menus can be displayed in locations defined by your theme.' ) . '</p>';
 661          }
 662  
 663          /*
 664           * Once multiple theme supports are allowed in WP_Customize_Panel,
 665           * this panel can be restricted to themes that support menus or widgets.
 666           */
 667          $this->manager->add_panel(
 668              new WP_Customize_Nav_Menus_Panel(
 669                  $this->manager,
 670                  'nav_menus',
 671                  array(
 672                      'title'       => __( 'Menus' ),
 673                      'description' => $description,
 674                      'priority'    => 100,
 675                  )
 676              )
 677          );
 678          $menus = wp_get_nav_menus();
 679  
 680          // Menu locations.
 681          $locations     = get_registered_nav_menus();
 682          $num_locations = count( $locations );
 683  
 684          if ( 1 === $num_locations ) {
 685              $description = '<p>' . __( 'Your theme can display menus in one location. Select which menu you would like to use.' ) . '</p>';
 686          } else {
 687              /* translators: %s: Number of menu locations. */
 688              $description = '<p>' . sprintf( _n( 'Your theme can display menus in %s location. Select which menu you would like to use.', 'Your theme can display menus in %s locations. Select which menu appears in each location.', $num_locations ), number_format_i18n( $num_locations ) ) . '</p>';
 689          }
 690  
 691          if ( current_theme_supports( 'widgets' ) ) {
 692              /* translators: URL to the Widgets panel of the Customizer. */
 693              $description .= '<p>' . sprintf( __( 'If your theme has widget areas, you can also add menus there. Visit the <a href="%s">Widgets panel</a> and add a &#8220;Navigation Menu widget&#8221; to display a menu in a sidebar or footer.' ), "javascript:wp.customize.panel( 'widgets' ).focus();" ) . '</p>';
 694          }
 695  
 696          $this->manager->add_section(
 697              'menu_locations',
 698              array(
 699                  'title'       => 1 === $num_locations ? _x( 'View Location', 'menu locations' ) : _x( 'View All Locations', 'menu locations' ),
 700                  'panel'       => 'nav_menus',
 701                  'priority'    => 30,
 702                  'description' => $description,
 703              )
 704          );
 705  
 706          $choices = array( '0' => __( '&mdash; Select &mdash;' ) );
 707          foreach ( $menus as $menu ) {
 708              $choices[ $menu->term_id ] = wp_html_excerpt( $menu->name, 40, '&hellip;' );
 709          }
 710  
 711          // Attempt to re-map the nav menu location assignments when previewing a theme switch.
 712          $mapped_nav_menu_locations = array();
 713          if ( ! $this->manager->is_theme_active() ) {
 714              $theme_mods = get_option( 'theme_mods_' . $this->manager->get_stylesheet(), array() );
 715  
 716              // If there is no data from a previous activation, start fresh.
 717              if ( empty( $theme_mods['nav_menu_locations'] ) ) {
 718                  $theme_mods['nav_menu_locations'] = array();
 719              }
 720  
 721              $mapped_nav_menu_locations = wp_map_nav_menu_locations( $theme_mods['nav_menu_locations'], $this->original_nav_menu_locations );
 722          }
 723  
 724          foreach ( $locations as $location => $description ) {
 725              $setting_id = "nav_menu_locations[{$location}]";
 726  
 727              $setting = $this->manager->get_setting( $setting_id );
 728              if ( $setting ) {
 729                  $setting->transport = 'postMessage';
 730                  remove_filter( "customize_sanitize_{$setting_id}", 'absint' );
 731                  add_filter( "customize_sanitize_{$setting_id}", array( $this, 'intval_base10' ) );
 732              } else {
 733                  $this->manager->add_setting(
 734                      $setting_id,
 735                      array(
 736                          'sanitize_callback' => array( $this, 'intval_base10' ),
 737                          'theme_supports'    => 'menus',
 738                          'type'              => 'theme_mod',
 739                          'transport'         => 'postMessage',
 740                          'default'           => 0,
 741                      )
 742                  );
 743              }
 744  
 745              // Override the assigned nav menu location if mapped during previewed theme switch.
 746              if ( empty( $changeset[ $setting_id ] ) && isset( $mapped_nav_menu_locations[ $location ] ) ) {
 747                  $this->manager->set_post_value( $setting_id, $mapped_nav_menu_locations[ $location ] );
 748              }
 749  
 750              $this->manager->add_control(
 751                  new WP_Customize_Nav_Menu_Location_Control(
 752                      $this->manager,
 753                      $setting_id,
 754                      array(
 755                          'label'       => $description,
 756                          'location_id' => $location,
 757                          'section'     => 'menu_locations',
 758                          'choices'     => $choices,
 759                      )
 760                  )
 761              );
 762          }
 763  
 764          // Used to denote post states for special pages.
 765          if ( ! function_exists( 'get_post_states' ) ) {
 766              require_once ABSPATH . 'wp-admin/includes/template.php';
 767          }
 768  
 769          // Register each menu as a Customizer section, and add each menu item to each menu.
 770          foreach ( $menus as $menu ) {
 771              $menu_id = $menu->term_id;
 772  
 773              // Create a section for each menu.
 774              $section_id = 'nav_menu[' . $menu_id . ']';
 775              $this->manager->add_section(
 776                  new WP_Customize_Nav_Menu_Section(
 777                      $this->manager,
 778                      $section_id,
 779                      array(
 780                          'title'    => html_entity_decode( $menu->name, ENT_QUOTES, get_bloginfo( 'charset' ) ),
 781                          'priority' => 10,
 782                          'panel'    => 'nav_menus',
 783                      )
 784                  )
 785              );
 786  
 787              $nav_menu_setting_id = 'nav_menu[' . $menu_id . ']';
 788              $this->manager->add_setting(
 789                  new WP_Customize_Nav_Menu_Setting(
 790                      $this->manager,
 791                      $nav_menu_setting_id,
 792                      array(
 793                          'transport' => 'postMessage',
 794                      )
 795                  )
 796              );
 797  
 798              // Add the menu contents.
 799              $menu_items = (array) wp_get_nav_menu_items( $menu_id );
 800  
 801              foreach ( array_values( $menu_items ) as $i => $item ) {
 802  
 803                  // Create a setting for each menu item (which doesn't actually manage data, currently).
 804                  $menu_item_setting_id = 'nav_menu_item[' . $item->ID . ']';
 805  
 806                  $value = (array) $item;
 807                  if ( empty( $value['post_title'] ) ) {
 808                      $value['title'] = '';
 809                  }
 810  
 811                  $value['nav_menu_term_id'] = $menu_id;
 812                  $this->manager->add_setting(
 813                      new WP_Customize_Nav_Menu_Item_Setting(
 814                          $this->manager,
 815                          $menu_item_setting_id,
 816                          array(
 817                              'value'     => $value,
 818                              'transport' => 'postMessage',
 819                          )
 820                      )
 821                  );
 822  
 823                  // Create a control for each menu item.
 824                  $this->manager->add_control(
 825                      new WP_Customize_Nav_Menu_Item_Control(
 826                          $this->manager,
 827                          $menu_item_setting_id,
 828                          array(
 829                              'label'    => $item->title,
 830                              'section'  => $section_id,
 831                              'priority' => 10 + $i,
 832                          )
 833                      )
 834                  );
 835              }
 836  
 837              // Note: other controls inside of this section get added dynamically in JS via the MenuSection.ready() function.
 838          }
 839  
 840          // Add the add-new-menu section and controls.
 841          $this->manager->add_section(
 842              'add_menu',
 843              array(
 844                  'type'     => 'new_menu',
 845                  'title'    => __( 'New Menu' ),
 846                  'panel'    => 'nav_menus',
 847                  'priority' => 20,
 848              )
 849          );
 850  
 851          $this->manager->add_setting(
 852              new WP_Customize_Filter_Setting(
 853                  $this->manager,
 854                  'nav_menus_created_posts',
 855                  array(
 856                      'transport'         => 'postMessage',
 857                      'type'              => 'option', // To prevent theme prefix in changeset.
 858                      'default'           => array(),
 859                      'sanitize_callback' => array( $this, 'sanitize_nav_menus_created_posts' ),
 860                  )
 861              )
 862          );
 863      }
 864  
 865      /**
 866       * Get the base10 intval.
 867       *
 868       * This is used as a setting's sanitize_callback; we can't use just plain
 869       * intval because the second argument is not what intval() expects.
 870       *
 871       * @since 4.3.0
 872       *
 873       * @param mixed $value Number to convert.
 874       * @return int Integer.
 875       */
 876  	public function intval_base10( $value ) {
 877          return intval( $value, 10 );
 878      }
 879  
 880      /**
 881       * Return an array of all the available item types.
 882       *
 883       * @since 4.3.0
 884       * @since 4.7.0  Each array item now includes a `$type_label` in addition to `$title`, `$type`, and `$object`.
 885       *
 886       * @return array The available menu item types.
 887       */
 888  	public function available_item_types() {
 889          $item_types = array();
 890  
 891          $post_types = get_post_types( array( 'show_in_nav_menus' => true ), 'objects' );
 892          if ( $post_types ) {
 893              foreach ( $post_types as $slug => $post_type ) {
 894                  $item_types[] = array(
 895                      'title'      => $post_type->labels->name,
 896                      'type_label' => $post_type->labels->singular_name,
 897                      'type'       => 'post_type',
 898                      'object'     => $post_type->name,
 899                  );
 900              }
 901          }
 902  
 903          $taxonomies = get_taxonomies( array( 'show_in_nav_menus' => true ), 'objects' );
 904          if ( $taxonomies ) {
 905              foreach ( $taxonomies as $slug => $taxonomy ) {
 906                  if ( 'post_format' === $taxonomy && ! current_theme_supports( 'post-formats' ) ) {
 907                      continue;
 908                  }
 909                  $item_types[] = array(
 910                      'title'      => $taxonomy->labels->name,
 911                      'type_label' => $taxonomy->labels->singular_name,
 912                      'type'       => 'taxonomy',
 913                      'object'     => $taxonomy->name,
 914                  );
 915              }
 916          }
 917  
 918          /**
 919           * Filters the available menu item types.
 920           *
 921           * @since 4.3.0
 922           * @since 4.7.0  Each array item now includes a `$type_label` in addition to `$title`, `$type`, and `$object`.
 923           *
 924           * @param array $item_types Navigation menu item types.
 925           */
 926          $item_types = apply_filters( 'customize_nav_menu_available_item_types', $item_types );
 927  
 928          return $item_types;
 929      }
 930  
 931      /**
 932       * Add a new `auto-draft` post.
 933       *
 934       * @since 4.7.0
 935       *
 936       * @param array $postarr {
 937       *     Post array. Note that post_status is overridden to be `auto-draft`.
 938       *
 939       * @var string $post_title   Post title. Required.
 940       * @var string $post_type    Post type. Required.
 941       * @var string $post_name    Post name.
 942       * @var string $post_content Post content.
 943       * }
 944       * @return WP_Post|WP_Error Inserted auto-draft post object or error.
 945       */
 946  	public function insert_auto_draft_post( $postarr ) {
 947          if ( ! isset( $postarr['post_type'] ) ) {
 948              return new WP_Error( 'unknown_post_type', __( 'Invalid post type.' ) );
 949          }
 950          if ( empty( $postarr['post_title'] ) ) {
 951              return new WP_Error( 'empty_title', __( 'Empty title.' ) );
 952          }
 953          if ( ! empty( $postarr['post_status'] ) ) {
 954              return new WP_Error( 'status_forbidden', __( 'Status is forbidden.' ) );
 955          }
 956  
 957          /*
 958           * If the changeset is a draft, this will change to draft the next time the changeset
 959           * is updated; otherwise, auto-draft will persist in autosave revisions, until save.
 960           */
 961          $postarr['post_status'] = 'auto-draft';
 962  
 963          // Auto-drafts are allowed to have empty post_names, so it has to be explicitly set.
 964          if ( empty( $postarr['post_name'] ) ) {
 965              $postarr['post_name'] = sanitize_title( $postarr['post_title'] );
 966          }
 967          if ( ! isset( $postarr['meta_input'] ) ) {
 968              $postarr['meta_input'] = array();
 969          }
 970          $postarr['meta_input']['_customize_draft_post_name'] = $postarr['post_name'];
 971          $postarr['meta_input']['_customize_changeset_uuid']  = $this->manager->changeset_uuid();
 972          unset( $postarr['post_name'] );
 973  
 974          add_filter( 'wp_insert_post_empty_content', '__return_false', 1000 );
 975          $r = wp_insert_post( wp_slash( $postarr ), true );
 976          remove_filter( 'wp_insert_post_empty_content', '__return_false', 1000 );
 977  
 978          if ( is_wp_error( $r ) ) {
 979              return $r;
 980          } else {
 981              return get_post( $r );
 982          }
 983      }
 984  
 985      /**
 986       * Ajax handler for adding a new auto-draft post.
 987       *
 988       * @since 4.7.0
 989       */
 990  	public function ajax_insert_auto_draft_post() {
 991          if ( ! check_ajax_referer( 'customize-menus', 'customize-menus-nonce', false ) ) {
 992              wp_send_json_error( 'bad_nonce', 400 );
 993          }
 994  
 995          if ( ! current_user_can( 'customize' ) ) {
 996              wp_send_json_error( 'customize_not_allowed', 403 );
 997          }
 998  
 999          if ( empty( $_POST['params'] ) || ! is_array( $_POST['params'] ) ) {
1000              wp_send_json_error( 'missing_params', 400 );
1001          }
1002  
1003          $params         = wp_unslash( $_POST['params'] );
1004          $illegal_params = array_diff( array_keys( $params ), array( 'post_type', 'post_title' ) );
1005          if ( ! empty( $illegal_params ) ) {
1006              wp_send_json_error( 'illegal_params', 400 );
1007          }
1008  
1009          $params = array_merge(
1010              array(
1011                  'post_type'  => '',
1012                  'post_title' => '',
1013              ),
1014              $params
1015          );
1016  
1017          if ( empty( $params['post_type'] ) || ! post_type_exists( $params['post_type'] ) ) {
1018              status_header( 400 );
1019              wp_send_json_error( 'missing_post_type_param' );
1020          }
1021  
1022          $post_type_object = get_post_type_object( $params['post_type'] );
1023          if ( ! current_user_can( $post_type_object->cap->create_posts ) || ! current_user_can( $post_type_object->cap->publish_posts ) ) {
1024              status_header( 403 );
1025              wp_send_json_error( 'insufficient_post_permissions' );
1026          }
1027  
1028          $params['post_title'] = trim( $params['post_title'] );
1029          if ( '' === $params['post_title'] ) {
1030              status_header( 400 );
1031              wp_send_json_error( 'missing_post_title' );
1032          }
1033  
1034          $r = $this->insert_auto_draft_post( $params );
1035          if ( is_wp_error( $r ) ) {
1036              $error = $r;
1037              if ( ! empty( $post_type_object->labels->singular_name ) ) {
1038                  $singular_name = $post_type_object->labels->singular_name;
1039              } else {
1040                  $singular_name = __( 'Post' );
1041              }
1042  
1043              $data = array(
1044                  /* translators: 1: Post type name, 2: Error message. */
1045                  'message' => sprintf( __( '%1$s could not be created: %2$s' ), $singular_name, $error->get_error_message() ),
1046              );
1047              wp_send_json_error( $data );
1048          } else {
1049              $post = $r;
1050              $data = array(
1051                  'post_id' => $post->ID,
1052                  'url'     => get_permalink( $post->ID ),
1053              );
1054              wp_send_json_success( $data );
1055          }
1056      }
1057  
1058      /**
1059       * Print the JavaScript templates used to render Menu Customizer components.
1060       *
1061       * Templates are imported into the JS use wp.template.
1062       *
1063       * @since 4.3.0
1064       */
1065  	public function print_templates() {
1066          ?>
1067          <script type="text/html" id="tmpl-available-menu-item">
1068              <li id="menu-item-tpl-{{ data.id }}" class="menu-item-tpl" data-menu-item-id="{{ data.id }}">
1069                  <div class="menu-item-bar">
1070                      <div class="menu-item-handle">
1071                          <span class="item-type" aria-hidden="true">{{ data.type_label }}</span>
1072                          <span class="item-title" aria-hidden="true">
1073                              <span class="menu-item-title<# if ( ! data.title ) { #> no-title<# } #>">{{ data.title || wp.customize.Menus.data.l10n.untitled }}</span>
1074                          </span>
1075                          <button type="button" class="button-link item-add">
1076                              <span class="screen-reader-text">
1077                              <?php
1078                                  /* translators: 1: Title of a menu item, 2: Type of a menu item. */
1079                                  printf( __( 'Add to menu: %1$s (%2$s)' ), '{{ data.title || wp.customize.Menus.data.l10n.untitled }}', '{{ data.type_label }}' );
1080                              ?>
1081                              </span>
1082                          </button>
1083                      </div>
1084                  </div>
1085              </li>
1086          </script>
1087  
1088          <script type="text/html" id="tmpl-menu-item-reorder-nav">
1089              <div class="menu-item-reorder-nav">
1090                  <?php
1091                  printf(
1092                      '<button type="button" class="menus-move-up">%1$s</button><button type="button" class="menus-move-down">%2$s</button><button type="button" class="menus-move-left">%3$s</button><button type="button" class="menus-move-right">%4$s</button>',
1093                      __( 'Move up' ),
1094                      __( 'Move down' ),
1095                      __( 'Move one level up' ),
1096                      __( 'Move one level down' )
1097                  );
1098                  ?>
1099              </div>
1100          </script>
1101  
1102          <script type="text/html" id="tmpl-nav-menu-delete-button">
1103              <div class="menu-delete-item">
1104                  <button type="button" class="button-link button-link-delete">
1105                      <?php _e( 'Delete Menu' ); ?>
1106                  </button>
1107              </div>
1108          </script>
1109  
1110          <script type="text/html" id="tmpl-nav-menu-submit-new-button">
1111              <p id="customize-new-menu-submit-description"><?php _e( 'Click &#8220;Next&#8221; to start adding links to your new menu.' ); ?></p>
1112              <button id="customize-new-menu-submit" type="button" class="button" aria-describedby="customize-new-menu-submit-description"><?php _e( 'Next' ); ?></button>
1113          </script>
1114  
1115          <script type="text/html" id="tmpl-nav-menu-locations-header">
1116              <span class="customize-control-title customize-section-title-menu_locations-heading">{{ data.l10n.locationsTitle }}</span>
1117              <p class="customize-control-description customize-section-title-menu_locations-description">{{ data.l10n.locationsDescription }}</p>
1118          </script>
1119  
1120          <script type="text/html" id="tmpl-nav-menu-create-menu-section-title">
1121              <p class="add-new-menu-notice">
1122                  <?php _e( 'It doesn&#8217;t look like your site has any menus yet. Want to build one? Click the button to start.' ); ?>
1123              </p>
1124              <p class="add-new-menu-notice">
1125                  <?php _e( 'You&#8217;ll create a menu, assign it a location, and add menu items like links to pages and categories. If your theme has multiple menu areas, you might need to create more than one.' ); ?>
1126              </p>
1127              <h3>
1128                  <button type="button" class="button customize-add-menu-button">
1129                      <?php _e( 'Create New Menu' ); ?>
1130                  </button>
1131              </h3>
1132          </script>
1133          <?php
1134      }
1135  
1136      /**
1137       * Print the HTML template used to render the add-menu-item frame.
1138       *
1139       * @since 4.3.0
1140       */
1141  	public function available_items_template() {
1142          ?>
1143          <div id="available-menu-items" class="accordion-container">
1144              <div class="customize-section-title">
1145                  <button type="button" class="customize-section-back" tabindex="-1">
1146                      <span class="screen-reader-text"><?php _e( 'Back' ); ?></span>
1147                  </button>
1148                  <h3>
1149                      <span class="customize-action">
1150                          <?php
1151                              /* translators: &#9656; is the unicode right-pointing triangle. %s: Section title in the Customizer. */
1152                              printf( __( 'Customizing &#9656; %s' ), esc_html( $this->manager->get_panel( 'nav_menus' )->title ) );
1153                          ?>
1154                      </span>
1155                      <?php _e( 'Add Menu Items' ); ?>
1156                  </h3>
1157              </div>
1158              <div id="available-menu-items-search" class="accordion-section cannot-expand">
1159                  <div class="accordion-section-title">
1160                      <label class="screen-reader-text" for="menu-items-search"><?php _e( 'Search Menu Items' ); ?></label>
1161                      <input type="text" id="menu-items-search" placeholder="<?php esc_attr_e( 'Search menu items&hellip;' ); ?>" aria-describedby="menu-items-search-desc" />
1162                      <p class="screen-reader-text" id="menu-items-search-desc"><?php _e( 'The search results will be updated as you type.' ); ?></p>
1163                      <span class="spinner"></span>
1164                  </div>
1165                  <div class="search-icon" aria-hidden="true"></div>
1166                  <button type="button" class="clear-results"><span class="screen-reader-text"><?php _e( 'Clear Results' ); ?></span></button>
1167                  <ul class="accordion-section-content available-menu-items-list" data-type="search"></ul>
1168              </div>
1169              <?php
1170  
1171              // Ensure the page post type comes first in the list.
1172              $item_types     = $this->available_item_types();
1173              $page_item_type = null;
1174              foreach ( $item_types as $i => $item_type ) {
1175                  if ( isset( $item_type['object'] ) && 'page' === $item_type['object'] ) {
1176                      $page_item_type = $item_type;
1177                      unset( $item_types[ $i ] );
1178                  }
1179              }
1180  
1181              $this->print_custom_links_available_menu_item();
1182              if ( $page_item_type ) {
1183                  $this->print_post_type_container( $page_item_type );
1184              }
1185              // Containers for per-post-type item browsing; items are added with JS.
1186              foreach ( $item_types as $item_type ) {
1187                  $this->print_post_type_container( $item_type );
1188              }
1189              ?>
1190          </div><!-- #available-menu-items -->
1191          <?php
1192      }
1193  
1194      /**
1195       * Print the markup for new menu items.
1196       *
1197       * To be used in the template #available-menu-items.
1198       *
1199       * @since 4.7.0
1200       *
1201       * @param array $available_item_type Menu item data to output, including title, type, and label.
1202       * @return void
1203       */
1204  	protected function print_post_type_container( $available_item_type ) {
1205          $id = sprintf( 'available-menu-items-%s-%s', $available_item_type['type'], $available_item_type['object'] );
1206          ?>
1207          <div id="<?php echo esc_attr( $id ); ?>" class="accordion-section">
1208              <h4 class="accordion-section-title" role="presentation">
1209                  <?php echo esc_html( $available_item_type['title'] ); ?>
1210                  <span class="spinner"></span>
1211                  <span class="no-items"><?php _e( 'No items' ); ?></span>
1212                  <button type="button" class="button-link" aria-expanded="false">
1213                      <span class="screen-reader-text">
1214                      <?php
1215                          /* translators: %s: Title of a section with menu items. */
1216                          printf( __( 'Toggle section: %s' ), esc_html( $available_item_type['title'] ) );
1217                      ?>
1218                          </span>
1219                      <span class="toggle-indicator" aria-hidden="true"></span>
1220                  </button>
1221              </h4>
1222              <div class="accordion-section-content">
1223                  <?php if ( 'post_type' === $available_item_type['type'] ) : ?>
1224                      <?php $post_type_obj = get_post_type_object( $available_item_type['object'] ); ?>
1225                      <?php if ( current_user_can( $post_type_obj->cap->create_posts ) && current_user_can( $post_type_obj->cap->publish_posts ) ) : ?>
1226                          <div class="new-content-item">
1227                              <label for="<?php echo esc_attr( 'create-item-input-' . $available_item_type['object'] ); ?>" class="screen-reader-text"><?php echo esc_html( $post_type_obj->labels->add_new_item ); ?></label>
1228                              <input type="text" id="<?php echo esc_attr( 'create-item-input-' . $available_item_type['object'] ); ?>" class="create-item-input" placeholder="<?php echo esc_attr( $post_type_obj->labels->add_new_item ); ?>">
1229                              <button type="button" class="button add-content"><?php _e( 'Add' ); ?></button>
1230                          </div>
1231                      <?php endif; ?>
1232                  <?php endif; ?>
1233                  <ul class="available-menu-items-list" data-type="<?php echo esc_attr( $available_item_type['type'] ); ?>" data-object="<?php echo esc_attr( $available_item_type['object'] ); ?>" data-type_label="<?php echo esc_attr( isset( $available_item_type['type_label'] ) ? $available_item_type['type_label'] : $available_item_type['type'] ); ?>"></ul>
1234              </div>
1235          </div>
1236          <?php
1237      }
1238  
1239      /**
1240       * Print the markup for available menu item custom links.
1241       *
1242       * @since 4.7.0
1243       *
1244       * @return void
1245       */
1246  	protected function print_custom_links_available_menu_item() {
1247          ?>
1248          <div id="new-custom-menu-item" class="accordion-section">
1249              <h4 class="accordion-section-title" role="presentation">
1250                  <?php _e( 'Custom Links' ); ?>
1251                  <button type="button" class="button-link" aria-expanded="false">
1252                      <span class="screen-reader-text"><?php _e( 'Toggle section: Custom Links' ); ?></span>
1253                      <span class="toggle-indicator" aria-hidden="true"></span>
1254                  </button>
1255              </h4>
1256              <div class="accordion-section-content customlinkdiv">
1257                  <input type="hidden" value="custom" id="custom-menu-item-type" name="menu-item[-1][menu-item-type]" />
1258                  <p id="menu-item-url-wrap" class="wp-clearfix">
1259                      <label class="howto" for="custom-menu-item-url"><?php _e( 'URL' ); ?></label>
1260                      <input id="custom-menu-item-url" name="menu-item[-1][menu-item-url]" type="text" class="code menu-item-textbox" placeholder="https://">
1261                  </p>
1262                  <p id="menu-item-name-wrap" class="wp-clearfix">
1263                      <label class="howto" for="custom-menu-item-name"><?php _e( 'Link Text' ); ?></label>
1264                      <input id="custom-menu-item-name" name="menu-item[-1][menu-item-title]" type="text" class="regular-text menu-item-textbox">
1265                  </p>
1266                  <p class="button-controls">
1267                      <span class="add-to-menu">
1268                          <input type="submit" class="button submit-add-to-menu right" value="<?php esc_attr_e( 'Add to Menu' ); ?>" name="add-custom-menu-item" id="custom-menu-item-submit">
1269                          <span class="spinner"></span>
1270                      </span>
1271                  </p>
1272              </div>
1273          </div>
1274          <?php
1275      }
1276  
1277      //
1278      // Start functionality specific to partial-refresh of menu changes in Customizer preview.
1279      //
1280  
1281      /**
1282       * Nav menu args used for each instance, keyed by the args HMAC.
1283       *
1284       * @since 4.3.0
1285       * @var array
1286       */
1287      public $preview_nav_menu_instance_args = array();
1288  
1289      /**
1290       * Filters arguments for dynamic nav_menu selective refresh partials.
1291       *
1292       * @since 4.5.0
1293       *
1294       * @param array|false $partial_args Partial args.
1295       * @param string      $partial_id   Partial ID.
1296       * @return array Partial args.
1297       */
1298  	public function customize_dynamic_partial_args( $partial_args, $partial_id ) {
1299  
1300          if ( preg_match( '/^nav_menu_instance\[[0-9a-f]{32}\]$/', $partial_id ) ) {
1301              if ( false === $partial_args ) {
1302                  $partial_args = array();
1303              }
1304              $partial_args = array_merge(
1305                  $partial_args,
1306                  array(
1307                      'type'                => 'nav_menu_instance',
1308                      'render_callback'     => array( $this, 'render_nav_menu_partial' ),
1309                      'container_inclusive' => true,
1310                      'settings'            => array(), // Empty because the nav menu instance may relate to a menu or a location.
1311                      'capability'          => 'edit_theme_options',
1312                  )
1313              );
1314          }
1315  
1316          return $partial_args;
1317      }
1318  
1319      /**
1320       * Add hooks for the Customizer preview.
1321       *
1322       * @since 4.3.0
1323       */
1324  	public function customize_preview_init() {
1325          add_action( 'wp_enqueue_scripts', array( $this, 'customize_preview_enqueue_deps' ) );
1326          add_filter( 'wp_nav_menu_args', array( $this, 'filter_wp_nav_menu_args' ), 1000 );
1327          add_filter( 'wp_nav_menu', array( $this, 'filter_wp_nav_menu' ), 10, 2 );
1328          add_filter( 'wp_footer', array( $this, 'export_preview_data' ), 1 );
1329          add_filter( 'customize_render_partials_response', array( $this, 'export_partial_rendered_nav_menu_instances' ) );
1330      }
1331  
1332      /**
1333       * Make the auto-draft status protected so that it can be queried.
1334       *
1335       * @since 4.7.0
1336       *
1337       * @global array $wp_post_statuses List of post statuses.
1338       */
1339  	public function make_auto_draft_status_previewable() {
1340          global $wp_post_statuses;
1341          $wp_post_statuses['auto-draft']->protected = true;
1342      }
1343  
1344      /**
1345       * Sanitize post IDs for posts created for nav menu items to be published.
1346       *
1347       * @since 4.7.0
1348       *
1349       * @param array $value Post IDs.
1350       * @return array Post IDs.
1351       */
1352  	public function sanitize_nav_menus_created_posts( $value ) {
1353          $post_ids = array();
1354          foreach ( wp_parse_id_list( $value ) as $post_id ) {
1355              if ( empty( $post_id ) ) {
1356                  continue;
1357              }
1358              $post = get_post( $post_id );
1359              if ( 'auto-draft' !== $post->post_status && 'draft' !== $post->post_status ) {
1360                  continue;
1361              }
1362              $post_type_obj = get_post_type_object( $post->post_type );
1363              if ( ! $post_type_obj ) {
1364                  continue;
1365              }
1366              if ( ! current_user_can( $post_type_obj->cap->publish_posts ) || ! current_user_can( 'edit_post', $post_id ) ) {
1367                  continue;
1368              }
1369              $post_ids[] = $post->ID;
1370          }
1371          return $post_ids;
1372      }
1373  
1374      /**
1375       * Publish the auto-draft posts that were created for nav menu items.
1376       *
1377       * The post IDs will have been sanitized by already by
1378       * `WP_Customize_Nav_Menu_Items::sanitize_nav_menus_created_posts()` to
1379       * remove any post IDs for which the user cannot publish or for which the
1380       * post is not an auto-draft.
1381       *
1382       * @since 4.7.0
1383       *
1384       * @param WP_Customize_Setting $setting Customizer setting object.
1385       */
1386  	public function save_nav_menus_created_posts( $setting ) {
1387          $post_ids = $setting->post_value();
1388          if ( ! empty( $post_ids ) ) {
1389              foreach ( $post_ids as $post_id ) {
1390  
1391                  // Prevent overriding the status that a user may have prematurely updated the post to.
1392                  $current_status = get_post_status( $post_id );
1393                  if ( 'auto-draft' !== $current_status && 'draft' !== $current_status ) {
1394                      continue;
1395                  }
1396  
1397                  $target_status = 'attachment' === get_post_type( $post_id ) ? 'inherit' : 'publish';
1398                  $args          = array(
1399                      'ID'          => $post_id,
1400                      'post_status' => $target_status,
1401                  );
1402                  $post_name     = get_post_meta( $post_id, '_customize_draft_post_name', true );
1403                  if ( $post_name ) {
1404                      $args['post_name'] = $post_name;
1405                  }
1406  
1407                  // Note that wp_publish_post() cannot be used because unique slugs need to be assigned.
1408                  wp_update_post( wp_slash( $args ) );
1409  
1410                  delete_post_meta( $post_id, '_customize_draft_post_name' );
1411              }
1412          }
1413      }
1414  
1415      /**
1416       * Keep track of the arguments that are being passed to wp_nav_menu().
1417       *
1418       * @since 4.3.0
1419       *
1420       * @see wp_nav_menu()
1421       * @see WP_Customize_Widgets::filter_dynamic_sidebar_params()
1422       *
1423       * @param array $args An array containing wp_nav_menu() arguments.
1424       * @return array Arguments.
1425       */
1426  	public function filter_wp_nav_menu_args( $args ) {
1427          /*
1428           * The following conditions determine whether or not this instance of
1429           * wp_nav_menu() can use selective refreshed. A wp_nav_menu() can be
1430           * selective refreshed if...
1431           */
1432          $can_partial_refresh = (
1433              // ...if wp_nav_menu() is directly echoing out the menu (and thus isn't manipulating the string after generated),
1434              ! empty( $args['echo'] )
1435              &&
1436              // ...and if the fallback_cb can be serialized to JSON, since it will be included in the placement context data,
1437              ( empty( $args['fallback_cb'] ) || is_string( $args['fallback_cb'] ) )
1438              &&
1439              // ...and if the walker can also be serialized to JSON, since it will be included in the placement context data as well,
1440              ( empty( $args['walker'] ) || is_string( $args['walker'] ) )
1441              // ...and if it has a theme location assigned or an assigned menu to display,
1442              && (
1443                  ! empty( $args['theme_location'] )
1444                  ||
1445                  ( ! empty( $args['menu'] ) && ( is_numeric( $args['menu'] ) || is_object( $args['menu'] ) ) )
1446              )
1447              &&
1448              // ...and if the nav menu would be rendered with a wrapper container element (upon which to attach data-* attributes).
1449              (
1450                  ! empty( $args['container'] )
1451                  ||
1452                  ( isset( $args['items_wrap'] ) && '<' === substr( $args['items_wrap'], 0, 1 ) )
1453              )
1454          );
1455          $args['can_partial_refresh'] = $can_partial_refresh;
1456  
1457          $exported_args = $args;
1458  
1459          // Empty out args which may not be JSON-serializable.
1460          if ( ! $can_partial_refresh ) {
1461              $exported_args['fallback_cb'] = '';
1462              $exported_args['walker']      = '';
1463          }
1464  
1465          /*
1466           * Replace object menu arg with a term_id menu arg, as this exports better
1467           * to JS and is easier to compare hashes.
1468           */
1469          if ( ! empty( $exported_args['menu'] ) && is_object( $exported_args['menu'] ) ) {
1470              $exported_args['menu'] = $exported_args['menu']->term_id;
1471          }
1472  
1473          ksort( $exported_args );
1474          $exported_args['args_hmac'] = $this->hash_nav_menu_args( $exported_args );
1475  
1476          $args['customize_preview_nav_menus_args']                            = $exported_args;
1477          $this->preview_nav_menu_instance_args[ $exported_args['args_hmac'] ] = $exported_args;
1478          return $args;
1479      }
1480  
1481      /**
1482       * Prepares wp_nav_menu() calls for partial refresh.
1483       *
1484       * Injects attributes into container element.
1485       *
1486       * @since 4.3.0
1487       *
1488       * @see wp_nav_menu()
1489       *
1490       * @param string $nav_menu_content The HTML content for the navigation menu.
1491       * @param object $args             An object containing wp_nav_menu() arguments.
1492       * @return string Nav menu HTML with selective refresh attributes added if partial can be refreshed.
1493       */
1494  	public function filter_wp_nav_menu( $nav_menu_content, $args ) {
1495          if ( isset( $args->customize_preview_nav_menus_args['can_partial_refresh'] ) && $args->customize_preview_nav_menus_args['can_partial_refresh'] ) {
1496              $attributes       = sprintf( ' data-customize-partial-id="%s"', esc_attr( 'nav_menu_instance[' . $args->customize_preview_nav_menus_args['args_hmac'] . ']' ) );
1497              $attributes      .= ' data-customize-partial-type="nav_menu_instance"';
1498              $attributes      .= sprintf( ' data-customize-partial-placement-context="%s"', esc_attr( wp_json_encode( $args->customize_preview_nav_menus_args ) ) );
1499              $nav_menu_content = preg_replace( '#^(<\w+)#', '$1 ' . str_replace( '\\', '\\\\', $attributes ), $nav_menu_content, 1 );
1500          }
1501          return $nav_menu_content;
1502      }
1503  
1504      /**
1505       * Hashes (hmac) the nav menu arguments to ensure they are not tampered with when
1506       * submitted in the Ajax request.
1507       *
1508       * Note that the array is expected to be pre-sorted.
1509       *
1510       * @since 4.3.0
1511       *
1512       * @param array $args The arguments to hash.
1513       * @return string Hashed nav menu arguments.
1514       */
1515  	public function hash_nav_menu_args( $args ) {
1516          return wp_hash( serialize( $args ) );
1517      }
1518  
1519      /**
1520       * Enqueue scripts for the Customizer preview.
1521       *
1522       * @since 4.3.0
1523       */
1524  	public function customize_preview_enqueue_deps() {
1525          wp_enqueue_script( 'customize-preview-nav-menus' ); // Note that we have overridden this.
1526      }
1527  
1528      /**
1529       * Exports data from PHP to JS.
1530       *
1531       * @since 4.3.0
1532       */
1533  	public function export_preview_data() {
1534  
1535          // Why not wp_localize_script? Because we're not localizing, and it forces values into strings.
1536          $exports = array(
1537              'navMenuInstanceArgs' => $this->preview_nav_menu_instance_args,
1538          );
1539          printf( '<script>var _wpCustomizePreviewNavMenusExports = %s;</script>', wp_json_encode( $exports ) );
1540      }
1541  
1542      /**
1543       * Export any wp_nav_menu() calls during the rendering of any partials.
1544       *
1545       * @since 4.5.0
1546       *
1547       * @param array $response Response.
1548       * @return array Response.
1549       */
1550  	public function export_partial_rendered_nav_menu_instances( $response ) {
1551          $response['nav_menu_instance_args'] = $this->preview_nav_menu_instance_args;
1552          return $response;
1553      }
1554  
1555      /**
1556       * Render a specific menu via wp_nav_menu() using the supplied arguments.
1557       *
1558       * @since 4.3.0
1559       *
1560       * @see wp_nav_menu()
1561       *
1562       * @param WP_Customize_Partial $partial       Partial.
1563       * @param array                $nav_menu_args Nav menu args supplied as container context.
1564       * @return string|false
1565       */
1566  	public function render_nav_menu_partial( $partial, $nav_menu_args ) {
1567          unset( $partial );
1568  
1569          if ( ! isset( $nav_menu_args['args_hmac'] ) ) {
1570              // Error: missing_args_hmac.
1571              return false;
1572          }
1573  
1574          $nav_menu_args_hmac = $nav_menu_args['args_hmac'];
1575          unset( $nav_menu_args['args_hmac'] );
1576  
1577          ksort( $nav_menu_args );
1578          if ( ! hash_equals( $this->hash_nav_menu_args( $nav_menu_args ), $nav_menu_args_hmac ) ) {
1579              // Error: args_hmac_mismatch.
1580              return false;
1581          }
1582  
1583          ob_start();
1584          wp_nav_menu( $nav_menu_args );
1585          $content = ob_get_clean();
1586  
1587          return $content;
1588      }
1589  }


Generated: Mon Jul 26 01:00:04 2021 Cross-referenced by PHPXref 0.7.1