WordPress at Your Fingertips
function is not described

Walker::paged_walk() public WP 2.7.0

paged_walk() - produce a page of nested elements

Given an array of hierarchical elements, the maximum depth, a specific page number, and number of elements per page, this function first determines all top level root elements belonging to that page, then lists them and all of their children in hierarchical order.

$max_depth = 0 means display all levels. $max_depth > 0 specifies the number of display levels.

{} It's a method of the class: Walker{}

No Hooks.

Return

String. XHTML of the specified page of elements

Usage

$Walker = new Walker();
$Walker->paged_walk( $elements, $max_depth, $page_num, $per_page, ...$args );
$elements(array) (required)
-
$max_depth(int) (required)
The maximum hierarchical depth.
$page_num(int) (required)
The specific page number, beginning with 1.
$per_page(int) (required)
-
...$args(mixed) (required)
Optional additional arguments.

Changelog

Since 2.7.0 Introduced.
Since 5.3.0 Formalized the existing ...$args parameter by adding it to the function signature.

Code of Walker::paged_walk() WP 5.8.1

public function paged_walk( $elements, $max_depth, $page_num, $per_page, ...$args ) {
	if ( empty( $elements ) || $max_depth < -1 ) {
		return '';
	}

	$output = '';

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

	$count = -1;
	if ( -1 == $max_depth ) {
		$total_top = count( $elements );
	}
	if ( $page_num < 1 || $per_page < 0 ) {
		// No paging.
		$paging = false;
		$start  = 0;
		if ( -1 == $max_depth ) {
			$end = $total_top;
		}
		$this->max_pages = 1;
	} else {
		$paging = true;
		$start  = ( (int) $page_num - 1 ) * (int) $per_page;
		$end    = $start + $per_page;
		if ( -1 == $max_depth ) {
			$this->max_pages = ceil( $total_top / $per_page );
		}
	}

	// Flat display.
	if ( -1 == $max_depth ) {
		if ( ! empty( $args[0]['reverse_top_level'] ) ) {
			$elements = array_reverse( $elements );
			$oldstart = $start;
			$start    = $total_top - $end;
			$end      = $total_top - $oldstart;
		}

		$empty_array = array();
		foreach ( $elements as $e ) {
			$count++;
			if ( $count < $start ) {
				continue;
			}
			if ( $count >= $end ) {
				break;
			}
			$this->display_element( $e, $empty_array, 1, 0, $args, $output );
		}
		return $output;
	}

	/*
	 * Separate elements into two buckets: top level and children elements.
	 * Children_elements is two dimensional array, e.g.
	 * $children_elements[10][] contains all sub-elements whose parent is 10.
	 */
	$top_level_elements = array();
	$children_elements  = array();
	foreach ( $elements as $e ) {
		if ( empty( $e->$parent_field ) ) {
			$top_level_elements[] = $e;
		} else {
			$children_elements[ $e->$parent_field ][] = $e;
		}
	}

	$total_top = count( $top_level_elements );
	if ( $paging ) {
		$this->max_pages = ceil( $total_top / $per_page );
	} else {
		$end = $total_top;
	}

	if ( ! empty( $args[0]['reverse_top_level'] ) ) {
		$top_level_elements = array_reverse( $top_level_elements );
		$oldstart           = $start;
		$start              = $total_top - $end;
		$end                = $total_top - $oldstart;
	}
	if ( ! empty( $args[0]['reverse_children'] ) ) {
		foreach ( $children_elements as $parent => $children ) {
			$children_elements[ $parent ] = array_reverse( $children );
		}
	}

	foreach ( $top_level_elements as $e ) {
		$count++;

		// For the last page, need to unset earlier children in order to keep track of orphans.
		if ( $end >= $total_top && $count < $start ) {
				$this->unset_children( $e, $children_elements );
		}

		if ( $count < $start ) {
			continue;
		}

		if ( $count >= $end ) {
			break;
		}

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

	if ( $end >= $total_top && 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;
}