/wp-includes/class-wp-customize-nav-menus.php

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