मेन्यू ट्री के एक हिस्से / शाखा को wp_nav_menu () का उपयोग करके प्रदर्शित करें


109

मेरे पास WP व्यवस्थापक में परिभाषित एक मेनू है जो इस तरह दिखता है:

वैकल्पिक शब्द

जब भी मैं किसी मूल पृष्ठ पर हूं, मैं साइडबार पर सभी बच्चे लिंक प्रदर्शित करने में सक्षम होना चाहता हूं। उदाहरण के लिए, यदि उपयोगकर्ता मेरे "हमारे बारे में" पृष्ठ पर है, तो मुझे साइडबार पर प्रदर्शित होने के लिए हरे रंग में हाइलाइट किए गए 4 लिंक की एक सूची चाहिए।

मैंने wp_nav_menu () के लिए प्रलेखन को देखा और लिंक उत्पन्न करते समय शुरुआती बिंदु के रूप में उपयोग करने के लिए किसी दिए गए मेनू के एक विशेष नोड को निर्दिष्ट करने के लिए कोई अंतर्निहित तरीका नहीं दिखाई देता है।

मैंने इसी तरह की स्थिति के लिए एक समाधान बनाया जो पृष्ठ माता-पिता द्वारा बनाए गए रिश्तों पर निर्भर करता था, लेकिन मैं एक की तलाश कर रहा हूं जो विशेष रूप से मेनू सिस्टम का उपयोग करता है। किसी भी सहायता की सराहना की जाएगी।


2
तो आप पूरे मेनू को कस्टम मेनू के रूप में बनाए रखना चाहते हैं, लेकिन एक कस्टम वॉकर बनाएं जो इसे केवल सक्रिय सबट्री का विस्तार करते हुए प्रदर्शित करता है? इस कोड की तरह , लेकिन wp_nav_menu के बजाय wp_list_pages का विस्तार? मैंने हाल ही में कुछ ऐसा ही किया है और यदि आप क्या देख रहे हैं, तो वह कोड पोस्ट कर सकता है ...
सुनहरा 1

1
@goldenapples, मैं वास्तव में यही हूं। यदि आपको जवाब के रूप में अपना कोड पोस्ट करने में कोई आपत्ति नहीं है तो मैं बहुत आभारी रहूंगा।
जेसगैविन

1
मुझे आश्चर्य है कि इस तरह की एक स्पष्ट उपयोगी कार्यक्षमता पहले से ही नहीं है। यह किसी भी साइट के लिए बहुत उपयोगी है जो "सीएमएस" करता है।
हैकर

मैं उपरोक्त समस्या या कुछ इसी तरह को हल करने की कोशिश कर रहा हूं। एक विकल्प के रूप में मैं यहां सीएसएस समाधान के साथ आया: stackoverflow.com/q/7640837/518169
23

जवाबों:


75

यह अभी भी मेरे दिमाग में था इसलिए मैंने इसे फिर से जारी किया और इस समाधान को एक साथ रखा, जो कि संदर्भ पर निर्भर नहीं करता है:

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;
}

प्रयोग

$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 );

लवली तकनीक! क्या मैं संभवतः इस बारे में कुछ पूछ सकता हूं: आप उन सूचीबद्ध सबमेनू पृष्ठों की सामग्री को खाके में कैसे प्रदर्शित करेंगे?
daniel.tosaba 5

2
@ daniel.tosaba आपको Walker_Nav_Menuकक्षा में फ़िल्टर उप-वर्ग या उपयोग करने की आवश्यकता होगी । टिप्पणी के लिए सभी मेनू सामान बहुत पसंद है - इसके बारे में नया प्रश्न पूछें?
रारस्ट


3
ऐसा शानदार जवाब। बहुत बहुत धन्यवाद। यह वास्तव में वर्डप्रेस के भीतर एक डिफ़ॉल्ट विकल्प होना चाहिए।
डॉट

3
वास्तव में साफ है। अगर किसी को दिलचस्पी है, तो वही करें लेकिन पेज आईडी द्वारा, wp_filter_object_listलाइन को बदल देंwp_filter_object_list( $items, array( 'object_id' => $args->submenu ), 'and', 'ID' );
बेन

14

@goldenapples: आपका वॉकर क्लास काम नहीं करता है। लेकिन विचार वास्तव में अच्छा है। मैंने आपके विचार के आधार पर एक वॉकर बनाया:

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;
    }
}

अब आप उपयोग कर सकते हैं:

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

आउटपुट एक सूची है जिसमें वर्तमान मूल तत्व है और यह बच्चे हैं (उनके बच्चे नहीं हैं)। Def: रूट तत्व: = शीर्ष स्तर मेनू आइटम जो वर्तमान पृष्ठ से मेल खाता है या वर्तमान पृष्ठ का माता-पिता या माता-पिता का माता-पिता है ...

यह मूल प्रश्न का उत्तर नहीं देता है लेकिन लगभग, क्योंकि अभी भी शीर्ष स्तर की वस्तु है। यह मेरे लिए ठीक है, क्योंकि मैं साइडबार के शीर्षक के रूप में शीर्ष स्तर का तत्व चाहता हूं। यदि आप इससे छुटकारा पाना चाहते हैं, तो आपको प्रदर्शन_लेमेंट को ओवरराइड करना पड़ सकता है या HTML- पार्सर का उपयोग करना पड़ सकता है।


12

हाय @ जेजेगिन :

नव मेनू को कस्टम पोस्ट प्रकारों और कस्टम टैक्सोनॉमी के संयोजन में संग्रहीत किया जाता है। प्रत्येक मेनू को कस्टम टैक्सोनॉमी (यानी , में पाया गया ) के पद (यानी "मेनू के बारे में" के रूप में संग्रहीत किया जाता है wp_terms) ।nav_menuwp_term_taxonomy

प्रत्येक नव मेनू आइटम को एक पोस्ट के रूप में संग्रहीत किया जाता है post_type=='nav_menu_item'(यानी "फर्म के बारे में" , पाया जाता है wp_posts) इसके साथ यह विशेषता है कि पोस्ट मेटा (इन wp_postmeta) के रूप में संग्रहीत meta_keyहै _menu_item_*जहां _menu_item_menu_item_parentआपके मेनू आइटम के मूल नव मेनू आइटम पोस्ट की आईडी है।

मेनू और मेनू आइटम के बीच संबंधों में संग्रहीत किया जाता है wp_term_relationships, जहां object_idसे संबंधित है $post->IDनव मेनू आइटम के लिए और $term_relationships->term_taxonomy_idमेनू में सामूहिक रूप से परिभाषित करने के लिए संबंधित wp_term_taxonomyऔर wp_terms

मुझे पूरा यकीन है कि दोनों को हुक करना 'wp_update_nav_menu'और 'wp_update_nav_menu_item'वास्तविक मेनू बनाना wp_termsऔर संबंधों का एक समानांतर सेट बनाना संभव होगा wp_term_taxonomyऔर wp_term_relationshipsजहां हर नव मेनू आइटम में उप-मेनू मेनू आइटम भी हैं, यह स्वयं का नव मेनू है।

आप हुक करना चाहते हैं 'wp_get_nav_menus' (जो मैंने सुझाव दिया था कि कुछ इसी तरह के काम के आधार पर मुझे WP 3.0 में जोड़ा जाना चाहिए) यह सुनिश्चित करने के लिए कि आपके उत्पन्न नव मेनस को व्यवस्थापक द्वारा उपयोगकर्ता द्वारा हेरफेर के लिए प्रदर्शित नहीं किया जाता है, अन्यथा वे आप वास्तव में तेजी से सिंक से बाहर निकलना चाहते हैं और फिर आपके हाथ में एक बुरा सपना होगा।

एक मजेदार और उपयोगी परियोजना की तरह लगता है, लेकिन यह थोड़ा अधिक कोड और परीक्षण है, क्योंकि मैं अभी से निपटने के लिए भाग में खर्च कर सकता हूं क्योंकि कुछ भी जो डेटा को सिंक्रनाइज़ करता है एक पीआईटीए हो जाता है जब यह सभी कीड़े (और क्योंकि बाहर इस्त्री करने के लिए आता है) भुगतान करने वाले ग्राहक मुझ पर काम करवाने के लिए दबाव डाल रहे हैं। :) लेकिन उपरोक्त जानकारी से लैस मैं एक बहुत ही प्रेरित वर्डप्रेस प्लगइन डेवलपर हूं, अगर वे चाहते तो इसे कोड कर सकते थे।

बेशक आप अब महसूस करते हैं कि अगर आप कोड करते हैं, तो आप इसे वापस यहां पोस्ट करने के लिए बाध्य हैं ताकि हम सभी आपके लार्जेस से लाभ उठा सकें! :-)


मुझे यकीन नहीं है कि आप जो कह रहे हैं, मैं उसका अनुसरण कर रहा हूं। मैं वर्तमान पृष्ठ से संबंधित "उप-मेनू" प्रदर्शित करने के लिए केवल-पढ़ने के लिए एक समाधान की तलाश कर रहा हूं, जिस पर उपयोगकर्ता है। क्या हम एक ही चीज के बारे में बात कर रहे हैं? - मैं हालांकि डेटाबेस स्कीमा के बारे में आपके गहन स्पष्टीकरण की सराहना करता हूं।
जेसेगैविन

@jessegavin - हां, यदि आप कॉल करना चाहते हैं wp_nav_menu()तो आपको मेनू को क्लोन करना होगा क्योंकि wp_nav_menu()मेनू संरचना को कसकर युग्मित किया गया है । अन्य विकल्प wp_nav_menu()कोड को कॉपी करना और सबमेनू के रूप में प्रदर्शित करने के लिए आवश्यक संशोधनों को बनाना है।
माइकस्किंकल

10

यह एक वॉकर एक्सटेंशन है जो आपको वही करना चाहिए जो आप देख रहे हैं:

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;
    }

}

पहले मैं अपनी टिप्पणी में संदर्भित mfields 'कोड के आधार पर शिथिल। मेनू को चलते समय यह सब चेक किया जाता है कि क्या वर्तमान तत्व (1) वर्तमान मेनू आइटम, या (2) वर्तमान मेनू आइटम का पूर्वज है या नहीं, और नीचे दी गई उपरीति को विस्तारित करता है, यदि दोनों में से कोई भी सत्य है। । उम्मीद है इससे आपका काम बनेगा।

इसका उपयोग करने के लिए, जब आप मेनू को कॉल करते हैं, तो बस "वाकर" तर्क जोड़ें:

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

ओह ... मैंने अभी आपके प्रश्न को फिर से पढ़ा और महसूस किया कि मैंने पहले इसे गलत समझा था। यह वॉकर अन्य सभी शीर्ष-स्तरीय मेनू आइटम दिखाएगा, बस उनका विस्तार नहीं करेगा। यह वही नहीं था जो आप करना चाहते थे। फिर भी, इस कोड को किसी भी तरह से संशोधित किया जा सकता है। बस के माध्यम से पाश को देखो $top_level_elementsऔर कॉल करने से पहले अपना खुद का परीक्षण जोड़ें $this->display_element
गोल्डनप्पल्स

क्या वर्तमान उपपृष्ठ की गहराई दिखाने के लिए इस वर्ग को प्राप्त करना संभव है? वह है .. यदि मेरे पास तीन या अधिक स्तरों की गहराई है, तो तीसरे और बाद के स्तर को वर्तमान (उप) पृष्ठ के लिए दिखाया गया है? फिलहाल, यह केवल ए> बी दिखाता है, न कि सी (सी तीसरा (स्तर) होने के नाते
ज़ोलोमन

@Zolomon - मुझे यकीन नहीं है कि मैं आपका सवाल समझ पा रहा हूं। यह 'मेन्यू-मेन्यू-आइटम', 'करंट-मेन्यू-पैरेंट', या 'करंट-मेन्यू-आंसर' के साथ किसी भी मेन्यू आइटम के तहत पूरे ट्री का विस्तार करना चाहिए। जब मैं इसका परीक्षण करता हूं, तो यह मेनू में सभी स्तरों को दिखाता है। आपको क्या करना है?
गोल्डनएपल्स

हो सकता है कि आप depthकॉल करने के लिए एक पैरामीटर पास करना चाहते हों wp_nav_menu, यदि आपका विषय किसी तरह 0 के डिफॉल्ट से अधिक है (सभी स्तरों को दिखाएं)?
गोल्डनएप्पल्स

8

अपडेट: मैंने इसे एक प्लगइन में बनाया है। यहाँ डाउनलोड करें


मुझे इसे स्वयं हल करने की आवश्यकता थी और अंततः मेनू लुकअप के परिणामों पर एक फ़िल्टर लिखना घाव हो गया। यह आपको wp_nav_menuसामान्य के रूप में उपयोग करने देता है , लेकिन मूल तत्व के शीर्षक के आधार पर मेनू का एक उप-भाग चुनें। submenuमेनू में एक पैरामीटर जोड़ें जैसे:

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

यहां तक ​​कि आप स्लैश डालकर कई स्तरों को गहराई तक जा सकते हैं:

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

या यदि आप एक सरणी के साथ पसंद करते हैं:

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

यह शीर्षक के एक स्लग संस्करण का उपयोग करता है, जिससे इसे राजधानियों और विराम चिह्नों की क्षमा करना चाहिए।


क्या आईडी के माध्यम से सबमेनू तक पहुंचना संभव है? मेरा मतलब है कि पेज आईडी, या पोस्ट आईडी।
दिगंबर

स्प्लिट () को हटा दिया गया है, $loc = split( "/", $loc );प्लगइन में बदलें$loc = preg_split( "~/~", $loc );
फ्लोरिस

मैं $ सबमेनू को वैकल्पिक बनाने का भी सुझाव दूंगा। इसलिए आप जरूरत पड़ने पर पूरे मेनू को प्राप्त कर सकते हैं। फ़िल्टर को शीर्ष पर जोड़ें: `if ((isset ($ args-> submenu)) {{$ आइटम वापस करें; } `
फ्लोरिस

8

मैंने अपने लिए निम्न वर्ग को एक साथ रखा। यह वर्तमान पृष्ठ के शीर्ष नौसेना माता-पिता को ढूंढ लेगा, या आप इसे वॉकर निर्माणकर्ता में एक लक्ष्य शीर्ष नौसेना आईडी दे सकते हैं।

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;
    }
}

नव कॉल:

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

4

@davidn @hakre हाय, मेरे पास HTML- पार्सर के बिना एक बदसूरत समाधान है या डिस्प्ले_लेमर ओवरराइडिंग है।

 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;
        }
    }

उन सभी की कोशिश करने के बाद, एल्प का समाधान केवल एक ही था जो मेरे लिए काम करता था। हालाँकि इसके साथ एक समस्या है। यह केवल पहले स्तर के बच्चों को दिखाता है, लेकिन तीसरे या चौथे स्तर के बच्चों को नहीं दिखाता है। मैं इसे करने के लिए दिनों से कोशिश कर रहा हूं। किसी को पता है कि कैसे उसके समाधान को संशोधित करने के लिए? पुनश्च। यह मुझे टिप्पणियों को जोड़ने की अनुमति नहीं देगा, इसलिए इसे एक उत्तर के रूप में करने की आवश्यकता है।
cchiera

3

नेवी मेन्यू आउटपुट में करंट आइटम, करंट आइटम आंसर आदि के लिए बहुत सारी क्लासेस शामिल हैं। कुछ स्थितियों में, मैं ऐसा करने में सक्षम रहा हूँ जो आप पूरे नेव ट्री आउटपुट को दे कर करना चाहते हैं, और फिर इसे नीचे करने के लिए css का उपयोग कर सकते हैं। वर्तमान पृष्ठ के केवल बच्चे, आदि।


3

मैंने एक संशोधित वॉकर बनाया जो मदद करना चाहिए! बिल्कुल सही नहीं है - यह कुछ खाली तत्वों को छोड़ देता है, लेकिन यह चाल करता है। संशोधन मूल रूप से उन $ current_branch बिट्स है। आशा है कि यह किसी की मदद करता है!

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

मेरे प्लगइन में कोड देखें या अपने उद्देश्य के लिए इसका इस्तेमाल करें;)

यह प्लगइन उन्नत "नेविगेशन मेनू" विजेट जोड़ता है। यह कई विकल्प प्रदान करता है जिसे विजेट के माध्यम से कस्टम मेनू के आउटपुट को अनुकूलित करने के लिए सेट किया जा सकता है।

विशेषताओं में शामिल:

  • कस्टम पदानुक्रम - "केवल संबंधित उप-आइटम" या "केवल सख्ती से संबंधित उप-आइटम"।
  • गहराई और अधिकतम स्तर प्रदर्शित करने के लिए + फ्लैट प्रदर्शन।
  • चयनित मेनू से शुरू होने वाले सभी मेनू आइटम प्रदर्शित करें।
  • वर्तमान तत्व या
    चयनित आइटम के केवल बच्चों के लिए सीधा रास्ता प्रदर्शित करें (मूल आइटम शामिल करने का विकल्प)।
  • एक विजेट ब्लॉक के लिए कस्टम वर्ग।
  • और wp_nav_menu फ़ंक्शन के लिए लगभग सभी पैरामीटर।

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

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.