Muestre una porción / rama del árbol de menús usando wp_nav_menu ()


109

Tengo un menú definido en WP Admin que se ve así:

texto alternativo

Quiero poder mostrar todos los enlaces secundarios en la barra lateral siempre que esté en una página principal. Por ejemplo, si el usuario está en mi página "Acerca de nosotros", quiero que aparezca una lista de los 4 enlaces resaltados en verde en la barra lateral.

Miré la documentación de wp_nav_menu () y no parece tener ninguna forma incorporada para especificar un nodo particular de un menú dado para usar como punto de partida al generar los enlaces.

Creé una solución para una situación similar que se basaba en las relaciones creadas por la página principal, pero estoy buscando una que utilice específicamente el sistema de menús. Cualquier ayuda sería apreciada.


2
Entonces, ¿desea mantener todo el menú como un menú personalizado, pero crear un andador personalizado que lo muestre expandiendo solo el subárbol activo? ¿ Le gusta este código , pero extiende wp_nav_menu en lugar de wp_list_pages? Recientemente hice algo similar y podría publicar el código si eso es lo que estás buscando ...
goldenapples

1
@goldenapples, eso es exactamente lo que busco. Si no le importa publicar su código como respuesta, estaría muy agradecido.
jessegavin

1
Me pregunto que una funcionalidad útil tan obvia aún no es construirla. En general, eso es muy útil para cualquier sitio que haga "CMS".
Hakre

Estoy tratando de resolver el problema anterior o algo similar. Como alternativa, se me ocurrió una solución CSS aquí: stackoverflow.com/q/7640837/518169
hyperknot

Respuestas:


75

Esto todavía estaba en mi mente, así que lo revisé y armé esta solución, que no depende tanto del contexto:

add_filter( 'wp_nav_menu_objects', 'submenu_limit', 10, 2 );

function submenu_limit( $items, $args ) {

    if ( empty( $args->submenu ) ) {
        return $items;
    }

    $ids       = wp_filter_object_list( $items, array( 'title' => $args->submenu ), 'and', 'ID' );
    $parent_id = array_pop( $ids );
    $children  = submenu_get_children_ids( $parent_id, $items );

    foreach ( $items as $key => $item ) {

        if ( ! in_array( $item->ID, $children ) ) {
            unset( $items[$key] );
        }
    }

    return $items;
}

function submenu_get_children_ids( $id, $items ) {

    $ids = wp_filter_object_list( $items, array( 'menu_item_parent' => $id ), 'and', 'ID' );

    foreach ( $ids as $id ) {

        $ids = array_merge( $ids, submenu_get_children_ids( $id, $items ) );
    }

    return $ids;
}

Uso

$args = array(
    'theme_location' => 'slug-of-the-menu', // the one used on register_nav_menus
    'submenu' => 'About Us', // could be used __() for translations
);

wp_nav_menu( $args );

Técnica encantadora! ¿Puedo preguntar algo posiblemente con respecto a este: cómo mostraría el contenido de las páginas de submenú enumeradas en la plantilla?
daniel.tosaba

2
@ daniel.tosaba necesitarás subclasificar o usar filtros en la Walker_Nav_Menuclase. Al igual que todas las cosas del menú, demasiado para comentar. ¿Hacer una nueva pregunta al respecto?
Rarst


3
Una respuesta tan fantástica. Muchas gracias. Esto realmente debería ser una opción predeterminada dentro de WordPress.
dotty

3
Realmente aseado. Si alguien está interesado, hacer lo mismo pero por ID de página, cambie la wp_filter_object_listlínea awp_filter_object_list( $items, array( 'object_id' => $args->submenu ), 'and', 'ID' );
Ben

14

@goldenapples: Tu Walker Class no funciona. Pero la idea es realmente buena. Creé un andador basado en tu idea:

class Selective_Walker extends Walker_Nav_Menu
{
    function walk( $elements, $max_depth) {

        $args = array_slice(func_get_args(), 2);
        $output = '';

        if ($max_depth < -1) //invalid parameter
            return $output;

        if (empty($elements)) //nothing to walk
            return $output;

        $id_field = $this->db_fields['id'];
        $parent_field = $this->db_fields['parent'];

        // flat display
        if ( -1 == $max_depth ) {
            $empty_array = array();
            foreach ( $elements as $e )
                $this->display_element( $e, $empty_array, 1, 0, $args, $output );
            return $output;
        }

        /*
         * need to display in hierarchical order
         * separate elements into two buckets: top level and children elements
         * children_elements is two dimensional array, eg.
         * children_elements[10][] contains all sub-elements whose parent is 10.
         */
        $top_level_elements = array();
        $children_elements  = array();
        foreach ( $elements as $e) {
            if ( 0 == $e->$parent_field )
                $top_level_elements[] = $e;
            else
                $children_elements[ $e->$parent_field ][] = $e;
        }

        /*
         * when none of the elements is top level
         * assume the first one must be root of the sub elements
         */
        if ( empty($top_level_elements) ) {

            $first = array_slice( $elements, 0, 1 );
            $root = $first[0];

            $top_level_elements = array();
            $children_elements  = array();
            foreach ( $elements as $e) {
                if ( $root->$parent_field == $e->$parent_field )
                    $top_level_elements[] = $e;
                else
                    $children_elements[ $e->$parent_field ][] = $e;
            }
        }

        $current_element_markers = array( 'current-menu-item', 'current-menu-parent', 'current-menu-ancestor' );  //added by continent7
        foreach ( $top_level_elements as $e ){  //changed by continent7
            // descend only on current tree
            $descend_test = array_intersect( $current_element_markers, $e->classes );
            if ( !empty( $descend_test ) ) 
                $this->display_element( $e, $children_elements, 2, 0, $args, $output );
        }

        /*
         * if we are displaying all levels, and remaining children_elements is not empty,
         * then we got orphans, which should be displayed regardless
         */
         /* removed by continent7
        if ( ( $max_depth == 0 ) && count( $children_elements ) > 0 ) {
            $empty_array = array();
            foreach ( $children_elements as $orphans )
                foreach( $orphans as $op )
                    $this->display_element( $op, $empty_array, 1, 0, $args, $output );
         }
        */
         return $output;
    }
}

Ahora puedes usar:

<?php wp_nav_menu( 
   array(
       'theme_location'=>'test', 
       'walker'=>new Selective_Walker() ) 
   ); ?>

El resultado es una lista que contiene el elemento raíz actual y sus elementos secundarios (no sus elementos secundarios). Def: Elemento raíz: = El elemento del menú de nivel superior que corresponde a la página actual o es padre de una página actual o padre de un padre ...

Esto no responde exactamente la pregunta original, pero casi, ya que todavía existe el elemento de nivel superior. Esto está bien para mí, porque quiero el elemento de nivel superior como título de la barra lateral. Si desea deshacerse de esto, es posible que deba anular display_element o usar un analizador HTML.


12

Hola @jessegavin :

Los menús de navegación se almacenan en una combinación de tipos de publicaciones personalizadas y taxonomías personalizadas. Cada menú se almacena como un Término (es decir, "Acerca del menú" , que se encuentra en wp_terms) de una Taxonomía personalizada (es decir nav_menu, que se encuentra en wp_term_taxonomy).

Cada elemento del menú de navegación se almacena como una publicación de post_type=='nav_menu_item'(es decir, "Acerca de la empresa" , que se encuentra en wp_posts) con sus atributos almacenados como meta meta (entrada wp_postmeta) utilizando un meta_keyprefijo de _menu_item_*dónde _menu_item_menu_item_parentestá la ID de la publicación del elemento de menú de navegación principal del elemento de menú.

La relación entre menús y elementos de menú se almacena en wp_term_relationshipsdonde se object_idrelaciona con el $post->IDelemento de menú Nav y se $term_relationships->term_taxonomy_idrelaciona con el menú definido colectivamente en wp_term_taxonomyy wp_terms.

Estoy bastante seguro de que sería posible conectar ambos 'wp_update_nav_menu'y 'wp_update_nav_menu_item'crear menús reales wp_termsy un conjunto paralelo de relaciones en wp_term_taxonomyy wp_term_relationshipsdonde cada elemento del menú de navegación que tenga elementos del menú de navegación secundaria también se convierta en su propio menú de navegación.

También querrá enganchar 'wp_get_nav_menus' (que sugerí que se agregue a WP 3.0 basado en un trabajo similar que estaba haciendo hace unos meses) para asegurarse de que los menús de navegación generados no se muestren para su manipulación por parte del usuario en el administrador, de lo contrario, saldría de la sincronización muy rápido y luego tendrías una pesadilla de datos en tu mano.

Suena como un proyecto divertido y útil, pero es un poco más de código y prueba de lo que puedo afrontar en este momento, en parte porque cualquier cosa que sincronice los datos tiende a ser un PITA cuando se trata de solucionar todos los errores (y porque los clientes que pagan me están presionando para que haga las cosas. :) Pero armado con la información anterior, soy un motivado desarrollador de plugins de WordPress que podría codificarlo si quisieran.

Por supuesto, ahora te das cuenta de que si lo codificas, estás obligado a publicarlo aquí para que todos podamos beneficiarnos de tu generosidad. :-)


No estoy seguro de seguir lo que estás diciendo. Estoy buscando una solución de solo lectura para mostrar "submenús" relacionados con la página actual en la que se encuentra un usuario. ¿Estamos hablando sobre la misma cosa? - Sin embargo, agradezco su explicación más profunda sobre el esquema de la base de datos.
jessegavin

@jessegavin : Sí, si desea llamar wp_nav_menu(), deberá clonar los menús porque wp_nav_menu()está estrechamente acoplado a la estructura del menú . La otra opción es copiar el wp_nav_menu()código y realizar las modificaciones necesarias para mostrar como un submenú.
MikeSchinkel

10

Esta es una extensión de Walker que debe hacer lo que estás buscando:

class Selective_Walker extends Walker_Nav_Menu
{

    function walk( $elements, $max_depth) {

        $args = array_slice(func_get_args(), 2);
        $output = '';

        if ($max_depth < -1) //invalid parameter
            return $output;

        if (empty($elements)) //nothing to walk
            return $output;

        $id_field = $this->db_fields['id'];
        $parent_field = $this->db_fields['parent'];

        // flat display
        if ( -1 == $max_depth ) {
            $empty_array = array();
            foreach ( $elements as $e )
                $this->display_element( $e, $empty_array, 1, 0, $args, $output );
            return $output;
        }

        /*
         * need to display in hierarchical order
         * separate elements into two buckets: top level and children elements
         * children_elements is two dimensional array, eg.
         * children_elements[10][] contains all sub-elements whose parent is 10.
         */
        $top_level_elements = array();
        $children_elements  = array();
        foreach ( $elements as $e) {
            if ( 0 == $e->$parent_field )
                $top_level_elements[] = $e;
            else
                $children_elements[ $e->$parent_field ][] = $e;
        }

        /*
         * when none of the elements is top level
         * assume the first one must be root of the sub elements
         */
        if ( empty($top_level_elements) ) {

            $first = array_slice( $elements, 0, 1 );
            $root = $first[0];

            $top_level_elements = array();
            $children_elements  = array();
            foreach ( $elements as $e) {
                if ( $root->$parent_field == $e->$parent_field )
                    $top_level_elements[] = $e;
                else
                    $children_elements[ $e->$parent_field ][] = $e;
            }
        }

        $current_element_markers = array( 'current-menu-item', 'current-menu-parent', 'current-menu-ancestor' );

        foreach ( $top_level_elements as $e ) {

            // descend only on current tree
            $descend_test = array_intersect( $current_element_markers, $e->classes );
            if ( empty( $descend_test ) )  unset ( $children_elements );

            $this->display_element( $e, $children_elements, $max_depth, 0, $args, $output );
        }

        /*
         * if we are displaying all levels, and remaining children_elements is not empty,
         * then we got orphans, which should be displayed regardless
         */
        if ( ( $max_depth == 0 ) && count( $children_elements ) > 0 ) {
            $empty_array = array();
            foreach ( $children_elements as $orphans )
                foreach( $orphans as $op )
                    $this->display_element( $op, $empty_array, 1, 0, $args, $output );
         }

         return $output;
    }

}

Basado libremente en el código de mfields al que hice referencia en mi comentario anteriormente. Todo lo que hace es verificar al recorrer el menú para ver si el elemento actual es (1) el elemento del menú actual, o (2) un antecesor del elemento del menú actual, y expande el subárbol debajo de él solo si alguna de esas condiciones es verdadera . Espero que esto funcione para usted.

Para usarlo, simplemente agregue un argumento de "caminante" cuando llame al menú, es decir:

<?php wp_nav_menu( 
   array(
       'theme_location'=>'test', 
       'walker'=>new Selective_Walker() ) 
   ); ?>

Oh ... acabo de releer tu pregunta y me di cuenta de que al principio la había entendido mal. Este andador mostrará todos los demás elementos del menú de nivel superior, pero no los expandirá. Esto no era exactamente lo que había querido hacer. Aún así, este código se puede modificar de la forma que desee. Simplemente mire el ciclo $top_level_elementsy agregue su propia prueba antes de la llamada $this->display_element.
goldenapples

¿Es posible hacer que esta clase muestre la profundidad de la subpágina actual? Es decir ... Si tengo una profundidad de tres o más niveles, ¿se muestran el tercer nivel y los siguientes para la (sub) página actual? Por el momento, solo muestra A> B, y no> C (C es el tercero (nivel)
Zolomon

@Zolomon - No estoy seguro de entender tu pregunta. Esto debería expandir todo el árbol debajo de cualquier elemento del menú con las clases 'current-menu-item', 'current-menu-parent' o 'current-menu-ancestor'. Cuando lo pruebo, muestra todos los niveles de subpáginas en el menú. Que estas buscando hacer
goldenapples

¿Quizás desee pasar un depthparámetro a la llamada wp_nav_menu, en caso de que su tema de alguna manera anule el valor predeterminado de 0 (mostrar todos los niveles)?
goldenapples

8

Actualización: hice esto en un complemento. Descarga aquí .


Necesitaba resolver esto yo mismo y finalmente terminé escribiendo un filtro en los resultados de la búsqueda del menú. Le permite usarlo wp_nav_menunormalmente, pero elija una subsección del menú basada en el título del elemento padre. Agregue un submenuparámetro al menú así:

wp_nav_menu(array(
  'menu' => 'header',
  'submenu' => 'About Us',
));

Incluso puede ir varios niveles de profundidad colocando barras en:

wp_nav_menu(array(
  'menu' => 'header',
  'submenu' => 'About Us/Board of Directors'
));

O si lo prefieres con una matriz:

wp_nav_menu(array(
  'menu' => 'header',
  'submenu' => array('About Us', 'Board of Directors')
));

Utiliza una versión babosa del título, lo que debería hacer que perdone cosas como mayúsculas y signos de puntuación.


¿Es posible acceder al submenú a través de la identificación? Me refiero a la identificación de la página o la identificación de la publicación.
Digerkam

split () está en desuso, reemplácelo $loc = split( "/", $loc );en el complemento con$loc = preg_split( "~/~", $loc );
Floris

También sugeriría hacer $ submenú opcional. Por lo tanto, aún puede recuperar todo el menú cuando sea necesario. Agregue esto al filtro en la parte superior: `if (! Isset ($ args-> submenu)) {return $ items; } `
Floris

8

Reuní la siguiente clase para mí. Encontrará el elemento principal de navegación superior de la página actual, o puede darle un ID de navegación superior de destino en el constructor del caminante.

class Walker_SubNav_Menu extends Walker_Nav_Menu {
    var $target_id = false;

    function __construct($target_id = false) {
        $this->target_id = $target_id;
    }

    function walk($items, $depth) {
        $args = array_slice(func_get_args(), 2);
        $args = $args[0];
        $parent_field = $this->db_fields['parent'];
        $target_id = $this->target_id;
        $filtered_items = array();

        // if the parent is not set, set it based on the post
        if (!$target_id) {
            global $post;
            foreach ($items as $item) {
                if ($item->object_id == $post->ID) {
                    $target_id = $item->ID;
                }
            }
        }

        // if there isn't a parent, do a regular menu
        if (!$target_id) return parent::walk($items, $depth, $args);

        // get the top nav item
        $target_id = $this->top_level_id($items, $target_id);

        // only include items under the parent
        foreach ($items as $item) {
            if (!$item->$parent_field) continue;

            $item_id = $this->top_level_id($items, $item->ID);

            if ($item_id == $target_id) {
                $filtered_items[] = $item;
            }
        }

        return parent::walk($filtered_items, $depth, $args);
    }

    // gets the top level ID for an item ID
    function top_level_id($items, $item_id) {
        $parent_field = $this->db_fields['parent'];

        $parents = array();
        foreach ($items as $item) {
            if ($item->$parent_field) {
                $parents[$item->ID] = $item->$parent_field;
            }
        }

        // find the top level item
        while (array_key_exists($item_id, $parents)) {
            $item_id = $parents[$item_id];
        }

        return $item_id;
    }
}

Llamada de navegación:

wp_nav_menu(array(
    'theme_location' => 'main_menu',
    'walker' => new Walker_SubNav_Menu(22), // with ID
));

4

@davidn @hakre Hola, tengo una solución fea sin un analizador de HTML o anular display_element.

 class Selective_Walker extends Walker_Nav_Menu
    {
        function walk( $elements, $max_depth) {

            $args = array_slice(func_get_args(), 2);
            $output = '';

            if ($max_depth < -1) //invalid parameter
                return $output;

            if (empty($elements)) //nothing to walk
                return $output;

            $id_field = $this->db_fields['id'];
            $parent_field = $this->db_fields['parent'];

            // flat display
            if ( -1 == $max_depth ) {
                $empty_array = array();
                foreach ( $elements as $e )
                    $this->display_element( $e, $empty_array, 1, 0, $args, $output );
                return $output;
            }

            /*
             * need to display in hierarchical order
             * separate elements into two buckets: top level and children elements
             * children_elements is two dimensional array, eg.
             * children_elements[10][] contains all sub-elements whose parent is 10.
             */
            $top_level_elements = array();
            $children_elements  = array();
            foreach ( $elements as $e) {
                if ( 0 == $e->$parent_field )
                    $top_level_elements[] = $e;
                else
                    $children_elements[ $e->$parent_field ][] = $e;
            }

            /*
             * when none of the elements is top level
             * assume the first one must be root of the sub elements
             */
            if ( empty($top_level_elements) ) {

                $first = array_slice( $elements, 0, 1 );
                $root = $first[0];

                $top_level_elements = array();
                $children_elements  = array();
                foreach ( $elements as $e) {
                    if ( $root->$parent_field == $e->$parent_field )
                        $top_level_elements[] = $e;
                    else
                        $children_elements[ $e->$parent_field ][] = $e;
                }
            }

            $current_element_markers = array( 'current-menu-item', 'current-menu-parent', 'current-menu-ancestor' );  //added by continent7
            foreach ( $top_level_elements as $e ){  //changed by continent7
                // descend only on current tree
                $descend_test = array_intersect( $current_element_markers, $e->classes );
                if ( !empty( $descend_test ) ) 
                    $this->display_element( $e, $children_elements, 2, 0, $args, $output );
            }

            /*
             * if we are displaying all levels, and remaining children_elements is not empty,
             * then we got orphans, which should be displayed regardless
             */
             /* removed by continent7
            if ( ( $max_depth == 0 ) && count( $children_elements ) > 0 ) {
                $empty_array = array();
                foreach ( $children_elements as $orphans )
                    foreach( $orphans as $op )
                        $this->display_element( $op, $empty_array, 1, 0, $args, $output );
             }
            */

/*added by alpguneysel  */
                $pos = strpos($output, '<a');
            $pos2 = strpos($output, 'a>');
            $topper= substr($output, 0, $pos).substr($output, $pos2+2);
            $pos3 = strpos($topper, '>');
            $lasst=substr($topper, $pos3+1);
            $submenu= substr($lasst, 0, -6);

        return $submenu;
        }
    }

Después de probarlos todos, la solución de Alp fue la única que funcionó para mí. Sin embargo, un problema con eso. Solo muestra los niños del primer nivel, pero no muestra los niños del tercer o cuarto nivel. Llevo días intentando hacerlo para hacerlo. ¿Alguien sabe cómo modificar su solución como tal? PD. No me deja agregar comentarios, así que necesito hacerlo como respuesta.
cchiera

3

La salida del menú de navegación incluye muchas clases para el elemento actual, el antepasado del elemento actual, etc. En algunas situaciones, he podido hacer lo que desea hacer dejando que la salida del árbol de navegación completa, y luego usando css para reducirlo a solo hijos de la página actual, etc.


3

¡Hice un andador modificado que debería ayudar! No es perfecto: deja algunos elementos vacíos, pero funciona. La modificación es básicamente esos $ current_branch bits. Espero que ayude a alguien!

class Kanec_Walker_Nav_Menu extends Walker {
/**
 * @see Walker::$tree_type
 * @since 3.0.0
 * @var string
 */
var $tree_type = array( 'post_type', 'taxonomy', 'custom' );

/**
 * @see Walker::$db_fields
 * @since 3.0.0
 * @todo Decouple this.
 * @var array
 */
var $db_fields = array( 'parent' => 'menu_item_parent', 'id' => 'db_id' );

/**
 * @see Walker::start_lvl()
 * @since 3.0.0
 *
 * @param string $output Passed by reference. Used to append additional content.
 * @param int $depth Depth of page. Used for padding.
 */
function start_lvl(&$output, $depth) {
    $indent = str_repeat("\t", $depth);
    $output .= "\n$indent<ul class=\"sub-menu\">\n";
}

/**
 * @see Walker::end_lvl()
 * @since 3.0.0
 *
 * @param string $output Passed by reference. Used to append additional content.
 * @param int $depth Depth of page. Used for padding.
 */
function end_lvl(&$output, $depth) {
    global $current_branch;
    if ($depth == 0) $current_branch = false;
    $indent = str_repeat("\t", $depth);
    $output .= "$indent</ul>\n";
}

/**
 * @see Walker::start_el()
 * @since 3.0.0
 *
 * @param string $output Passed by reference. Used to append additional content.
 * @param object $item Menu item data object.
 * @param int $depth Depth of menu item. Used for padding.
 * @param int $current_page Menu item ID.
 * @param object $args
 */
function start_el(&$output, $item, $depth, $args) {
    global $wp_query;
    global $current_branch;

    // Is this menu item in the current branch?
    if(in_array('current-menu-ancestor',$item->classes) ||
    in_array('current-menu-parent',$item->classes) ||
    in_array('current-menu-item',$item->classes)) {
        $current_branch = true; 
    }

    if($current_branch && $depth > 0) {
        $indent = ( $depth ) ? str_repeat( "\t", $depth ) : '';

        $class_names = $value = '';

        $classes = empty( $item->classes ) ? array() : (array) $item->classes;
        $classes[] = 'menu-item-' . $item->ID;

        $class_names = join( ' ', apply_filters( 'nav_menu_css_class', array_filter( $classes ), $item ) );
        $class_names = ' class="' . esc_attr( $class_names ) . '"';

        $id = apply_filters( 'nav_menu_item_id', 'menu-item-'. $item->ID, $item, $args );
        $id = strlen( $id ) ? ' id="' . esc_attr( $id ) . '"' : '';

        $output .= $indent . '<li' . $id . $value . $class_names .'>';

        $attributes  = ! empty( $item->attr_title ) ? ' title="'  . esc_attr( $item->attr_title ) .'"' : '';
        $attributes .= ! empty( $item->target )     ? ' target="' . esc_attr( $item->target     ) .'"' : '';
        $attributes .= ! empty( $item->xfn )        ? ' rel="'    . esc_attr( $item->xfn        ) .'"' : '';
        $attributes .= ! empty( $item->url )        ? ' href="'   . esc_attr( $item->url        ) .'"' : '';

        $item_output = $args->before;
        $item_output .= '<a'. $attributes .'>';
        $item_output .= $args->link_before . apply_filters( 'the_title', $item->title, $item->ID ) . $args->link_after;
        $item_output .= '</a>';
        $item_output .= $args->after;

        $output .= apply_filters( 'walker_nav_menu_start_el', $item_output, $item, $depth, $args );
    }

}

/**
 * @see Walker::end_el()
 * @since 3.0.0
 *
 * @param string $output Passed by reference. Used to append additional content.
 * @param object $item Page data object. Not used.
 * @param int $depth Depth of page. Not Used.
 */
function end_el(&$output, $item, $depth) {
    global $current_branch;
    if($current_branch && $depth > 0) $output .= "</li>\n";
    if($depth == 0) $current_branch = 0;
}

}


3

Mira el código en mi plugin o úsalo para tu propósito;)

Este complemento agrega un widget mejorado de "Menú de navegación". Ofrece muchas opciones que se pueden configurar para personalizar la salida del menú personalizado a través del widget.

Las características incluyen:

  • Jerarquía personalizada: "Solo subelementos relacionados" o "Solo subelementos estrictamente relacionados".
  • Profundidad inicial y nivel máximo para mostrar + pantalla plana.
  • Mostrar todos los elementos del menú que comienzan con el seleccionado.
  • Mostrar solo la ruta directa al elemento actual o solo los elementos secundarios del
    elemento seleccionado (opción para incluir el elemento principal).
  • Clase personalizada para un bloque de widgets.
  • Y casi todos los parámetros para la función wp_nav_menu.

http://wordpress.org/extend/plugins/advanced-menu-widget/