[ Index ]

PHP Cross Reference of WordPress Trunk (Updated Daily)

Search

title

Body

[close]

/wp-includes/ -> post-template.php (source)

   1  <?php
   2  /**
   3   * WordPress Post Template Functions.
   4   *
   5   * Gets content for the current post in the loop.
   6   *
   7   * @package WordPress
   8   * @subpackage Template
   9   */
  10  
  11  /**
  12   * Displays the ID of the current item in the WordPress Loop.
  13   *
  14   * @since 0.71
  15   */
  16  function the_ID() { // phpcs:ignore WordPress.NamingConventions.ValidFunctionName.FunctionNameInvalid
  17      echo get_the_ID();
  18  }
  19  
  20  /**
  21   * Retrieves the ID of the current item in the WordPress Loop.
  22   *
  23   * @since 2.1.0
  24   *
  25   * @return int|false The ID of the current item in the WordPress Loop. False if $post is not set.
  26   */
  27  function get_the_ID() { // phpcs:ignore WordPress.NamingConventions.ValidFunctionName.FunctionNameInvalid
  28      $post = get_post();
  29      return ! empty( $post ) ? $post->ID : false;
  30  }
  31  
  32  /**
  33   * Displays or retrieves the current post title with optional markup.
  34   *
  35   * @since 0.71
  36   *
  37   * @param string $before  Optional. Markup to prepend to the title. Default empty.
  38   * @param string $after   Optional. Markup to append to the title. Default empty.
  39   * @param bool   $display Optional. Whether to echo or return the title. Default true for echo.
  40   * @return void|string Void if `$display` argument is true or the title is empty,
  41   *                     current post title if `$display` is false.
  42   */
  43  function the_title( $before = '', $after = '', $display = true ) {
  44      $title = get_the_title();
  45  
  46      if ( strlen( $title ) === 0 ) {
  47          return;
  48      }
  49  
  50      $title = $before . $title . $after;
  51  
  52      if ( $display ) {
  53          echo $title;
  54      } else {
  55          return $title;
  56      }
  57  }
  58  
  59  /**
  60   * Sanitizes the current title when retrieving or displaying.
  61   *
  62   * Works like the_title(), except the parameters can be in a string or
  63   * an array. See the function for what can be override in the $args parameter.
  64   *
  65   * The title before it is displayed will have the tags stripped and esc_attr()
  66   * before it is passed to the user or displayed. The default as with the_title(),
  67   * is to display the title.
  68   *
  69   * @since 2.3.0
  70   *
  71   * @param string|array $args {
  72   *     Title attribute arguments. Optional.
  73   *
  74   *     @type string  $before Markup to prepend to the title. Default empty.
  75   *     @type string  $after  Markup to append to the title. Default empty.
  76   *     @type bool    $echo   Whether to echo or return the title. Default true for echo.
  77   *     @type WP_Post $post   Current post object to retrieve the title for.
  78   * }
  79   * @return void|string Void if 'echo' argument is true, the title attribute if 'echo' is false.
  80   */
  81  function the_title_attribute( $args = '' ) {
  82      $defaults    = array(
  83          'before' => '',
  84          'after'  => '',
  85          'echo'   => true,
  86          'post'   => get_post(),
  87      );
  88      $parsed_args = wp_parse_args( $args, $defaults );
  89  
  90      $title = get_the_title( $parsed_args['post'] );
  91  
  92      if ( strlen( $title ) === 0 ) {
  93          return;
  94      }
  95  
  96      $title = $parsed_args['before'] . $title . $parsed_args['after'];
  97      $title = esc_attr( strip_tags( $title ) );
  98  
  99      if ( $parsed_args['echo'] ) {
 100          echo $title;
 101      } else {
 102          return $title;
 103      }
 104  }
 105  
 106  /**
 107   * Retrieves the post title.
 108   *
 109   * If the post is protected and the visitor is not an admin, then "Protected"
 110   * will be inserted before the post title. If the post is private, then
 111   * "Private" will be inserted before the post title.
 112   *
 113   * @since 0.71
 114   *
 115   * @param int|WP_Post $post Optional. Post ID or WP_Post object. Default is global $post.
 116   * @return string
 117   */
 118  function get_the_title( $post = 0 ) {
 119      $post = get_post( $post );
 120  
 121      $post_title = isset( $post->post_title ) ? $post->post_title : '';
 122      $post_id    = isset( $post->ID ) ? $post->ID : 0;
 123  
 124      if ( ! is_admin() ) {
 125          if ( ! empty( $post->post_password ) ) {
 126  
 127              /* translators: %s: Protected post title. */
 128              $prepend = __( 'Protected: %s' );
 129  
 130              /**
 131               * Filters the text prepended to the post title for protected posts.
 132               *
 133               * The filter is only applied on the front end.
 134               *
 135               * @since 2.8.0
 136               *
 137               * @param string  $prepend Text displayed before the post title.
 138               *                         Default 'Protected: %s'.
 139               * @param WP_Post $post    Current post object.
 140               */
 141              $protected_title_format = apply_filters( 'protected_title_format', $prepend, $post );
 142  
 143              $post_title = sprintf( $protected_title_format, $post_title );
 144          } elseif ( isset( $post->post_status ) && 'private' === $post->post_status ) {
 145  
 146              /* translators: %s: Private post title. */
 147              $prepend = __( 'Private: %s' );
 148  
 149              /**
 150               * Filters the text prepended to the post title of private posts.
 151               *
 152               * The filter is only applied on the front end.
 153               *
 154               * @since 2.8.0
 155               *
 156               * @param string  $prepend Text displayed before the post title.
 157               *                         Default 'Private: %s'.
 158               * @param WP_Post $post    Current post object.
 159               */
 160              $private_title_format = apply_filters( 'private_title_format', $prepend, $post );
 161  
 162              $post_title = sprintf( $private_title_format, $post_title );
 163          }
 164      }
 165  
 166      /**
 167       * Filters the post title.
 168       *
 169       * @since 0.71
 170       *
 171       * @param string $post_title The post title.
 172       * @param int    $post_id    The post ID.
 173       */
 174      return apply_filters( 'the_title', $post_title, $post_id );
 175  }
 176  
 177  /**
 178   * Displays the Post Global Unique Identifier (guid).
 179   *
 180   * The guid will appear to be a link, but should not be used as a link to the
 181   * post. The reason you should not use it as a link, is because of moving the
 182   * blog across domains.
 183   *
 184   * URL is escaped to make it XML-safe.
 185   *
 186   * @since 1.5.0
 187   *
 188   * @param int|WP_Post $post Optional. Post ID or post object. Default is global $post.
 189   */
 190  function the_guid( $post = 0 ) {
 191      $post = get_post( $post );
 192  
 193      $post_guid = isset( $post->guid ) ? get_the_guid( $post ) : '';
 194      $post_id   = isset( $post->ID ) ? $post->ID : 0;
 195  
 196      /**
 197       * Filters the escaped Global Unique Identifier (guid) of the post.
 198       *
 199       * @since 4.2.0
 200       *
 201       * @see get_the_guid()
 202       *
 203       * @param string $post_guid Escaped Global Unique Identifier (guid) of the post.
 204       * @param int    $post_id   The post ID.
 205       */
 206      echo apply_filters( 'the_guid', $post_guid, $post_id );
 207  }
 208  
 209  /**
 210   * Retrieves the Post Global Unique Identifier (guid).
 211   *
 212   * The guid will appear to be a link, but should not be used as an link to the
 213   * post. The reason you should not use it as a link, is because of moving the
 214   * blog across domains.
 215   *
 216   * @since 1.5.0
 217   *
 218   * @param int|WP_Post $post Optional. Post ID or post object. Default is global $post.
 219   * @return string
 220   */
 221  function get_the_guid( $post = 0 ) {
 222      $post = get_post( $post );
 223  
 224      $post_guid = isset( $post->guid ) ? $post->guid : '';
 225      $post_id   = isset( $post->ID ) ? $post->ID : 0;
 226  
 227      /**
 228       * Filters the Global Unique Identifier (guid) of the post.
 229       *
 230       * @since 1.5.0
 231       *
 232       * @param string $post_guid Global Unique Identifier (guid) of the post.
 233       * @param int    $post_id   The post ID.
 234       */
 235      return apply_filters( 'get_the_guid', $post_guid, $post_id );
 236  }
 237  
 238  /**
 239   * Displays the post content.
 240   *
 241   * @since 0.71
 242   *
 243   * @param string $more_link_text Optional. Content for when there is more text.
 244   * @param bool   $strip_teaser   Optional. Strip teaser content before the more text. Default false.
 245   */
 246  function the_content( $more_link_text = null, $strip_teaser = false ) {
 247      $content = get_the_content( $more_link_text, $strip_teaser );
 248  
 249      /**
 250       * Filters the post content.
 251       *
 252       * @since 0.71
 253       *
 254       * @param string $content Content of the current post.
 255       */
 256      $content = apply_filters( 'the_content', $content );
 257      $content = str_replace( ']]>', ']]&gt;', $content );
 258      echo $content;
 259  }
 260  
 261  /**
 262   * Retrieves the post content.
 263   *
 264   * @since 0.71
 265   * @since 5.2.0 Added the `$post` parameter.
 266   *
 267   * @global int   $page      Page number of a single post/page.
 268   * @global int   $more      Boolean indicator for whether single post/page is being viewed.
 269   * @global bool  $preview   Whether post/page is in preview mode.
 270   * @global array $pages     Array of all pages in post/page. Each array element contains
 271   *                          part of the content separated by the `<!--nextpage-->` tag.
 272   * @global int   $multipage Boolean indicator for whether multiple pages are in play.
 273   *
 274   * @param string             $more_link_text Optional. Content for when there is more text.
 275   * @param bool               $strip_teaser   Optional. Strip teaser content before the more text. Default false.
 276   * @param WP_Post|object|int $post           Optional. WP_Post instance or Post ID/object. Default null.
 277   * @return string
 278   */
 279  function get_the_content( $more_link_text = null, $strip_teaser = false, $post = null ) {
 280      global $page, $more, $preview, $pages, $multipage;
 281  
 282      $_post = get_post( $post );
 283  
 284      if ( ! ( $_post instanceof WP_Post ) ) {
 285          return '';
 286      }
 287  
 288      /*
 289       * Use the globals if the $post parameter was not specified,
 290       * but only after they have been set up in setup_postdata().
 291       */
 292      if ( null === $post && did_action( 'the_post' ) ) {
 293          $elements = compact( 'page', 'more', 'preview', 'pages', 'multipage' );
 294      } else {
 295          $elements = generate_postdata( $_post );
 296      }
 297  
 298      if ( null === $more_link_text ) {
 299          $more_link_text = sprintf(
 300              '<span aria-label="%1$s">%2$s</span>',
 301              sprintf(
 302                  /* translators: %s: Post title. */
 303                  __( 'Continue reading %s' ),
 304                  the_title_attribute(
 305                      array(
 306                          'echo' => false,
 307                          'post' => $_post,
 308                      )
 309                  )
 310              ),
 311              __( '(more&hellip;)' )
 312          );
 313      }
 314  
 315      $output     = '';
 316      $has_teaser = false;
 317  
 318      // If post password required and it doesn't match the cookie.
 319      if ( post_password_required( $_post ) ) {
 320          return get_the_password_form( $_post );
 321      }
 322  
 323      // If the requested page doesn't exist.
 324      if ( $elements['page'] > count( $elements['pages'] ) ) {
 325          // Give them the highest numbered page that DOES exist.
 326          $elements['page'] = count( $elements['pages'] );
 327      }
 328  
 329      $page_no = $elements['page'];
 330      $content = $elements['pages'][ $page_no - 1 ];
 331      if ( preg_match( '/<!--more(.*?)?-->/', $content, $matches ) ) {
 332          if ( has_block( 'more', $content ) ) {
 333              // Remove the core/more block delimiters. They will be left over after $content is split up.
 334              $content = preg_replace( '/<!-- \/?wp:more(.*?) -->/', '', $content );
 335          }
 336  
 337          $content = explode( $matches[0], $content, 2 );
 338  
 339          if ( ! empty( $matches[1] ) && ! empty( $more_link_text ) ) {
 340              $more_link_text = strip_tags( wp_kses_no_null( trim( $matches[1] ) ) );
 341          }
 342  
 343          $has_teaser = true;
 344      } else {
 345          $content = array( $content );
 346      }
 347  
 348      if ( str_contains( $_post->post_content, '<!--noteaser-->' )
 349          && ( ! $elements['multipage'] || 1 === $elements['page'] )
 350      ) {
 351          $strip_teaser = true;
 352      }
 353  
 354      $teaser = $content[0];
 355  
 356      if ( $elements['more'] && $strip_teaser && $has_teaser ) {
 357          $teaser = '';
 358      }
 359  
 360      $output .= $teaser;
 361  
 362      if ( count( $content ) > 1 ) {
 363          if ( $elements['more'] ) {
 364              $output .= '<span id="more-' . $_post->ID . '"></span>' . $content[1];
 365          } else {
 366              if ( ! empty( $more_link_text ) ) {
 367  
 368                  /**
 369                   * Filters the Read More link text.
 370                   *
 371                   * @since 2.8.0
 372                   *
 373                   * @param string $more_link_element Read More link element.
 374                   * @param string $more_link_text    Read More text.
 375                   */
 376                  $output .= apply_filters( 'the_content_more_link', ' <a href="' . get_permalink( $_post ) . "#more-{$_post->ID}\" class=\"more-link\">$more_link_text</a>", $more_link_text );
 377              }
 378              $output = force_balance_tags( $output );
 379          }
 380      }
 381  
 382      return $output;
 383  }
 384  
 385  /**
 386   * Displays the post excerpt.
 387   *
 388   * @since 0.71
 389   */
 390  function the_excerpt() {
 391  
 392      /**
 393       * Filters the displayed post excerpt.
 394       *
 395       * @since 0.71
 396       *
 397       * @see get_the_excerpt()
 398       *
 399       * @param string $post_excerpt The post excerpt.
 400       */
 401      echo apply_filters( 'the_excerpt', get_the_excerpt() );
 402  }
 403  
 404  /**
 405   * Retrieves the post excerpt.
 406   *
 407   * @since 0.71
 408   * @since 4.5.0 Introduced the `$post` parameter.
 409   *
 410   * @param int|WP_Post $post Optional. Post ID or WP_Post object. Default is global $post.
 411   * @return string Post excerpt.
 412   */
 413  function get_the_excerpt( $post = null ) {
 414      if ( is_bool( $post ) ) {
 415          _deprecated_argument( __FUNCTION__, '2.3.0' );
 416      }
 417  
 418      $post = get_post( $post );
 419      if ( empty( $post ) ) {
 420          return '';
 421      }
 422  
 423      if ( post_password_required( $post ) ) {
 424          return __( 'There is no excerpt because this is a protected post.' );
 425      }
 426  
 427      /**
 428       * Filters the retrieved post excerpt.
 429       *
 430       * @since 1.2.0
 431       * @since 4.5.0 Introduced the `$post` parameter.
 432       *
 433       * @param string  $post_excerpt The post excerpt.
 434       * @param WP_Post $post         Post object.
 435       */
 436      return apply_filters( 'get_the_excerpt', $post->post_excerpt, $post );
 437  }
 438  
 439  /**
 440   * Determines whether the post has a custom excerpt.
 441   *
 442   * For more information on this and similar theme functions, check out
 443   * the {@link https://developer.wordpress.org/themes/basics/conditional-tags/
 444   * Conditional Tags} article in the Theme Developer Handbook.
 445   *
 446   * @since 2.3.0
 447   *
 448   * @param int|WP_Post $post Optional. Post ID or WP_Post object. Default is global $post.
 449   * @return bool True if the post has a custom excerpt, false otherwise.
 450   */
 451  function has_excerpt( $post = 0 ) {
 452      $post = get_post( $post );
 453      return ( ! empty( $post->post_excerpt ) );
 454  }
 455  
 456  /**
 457   * Displays the classes for the post container element.
 458   *
 459   * @since 2.7.0
 460   *
 461   * @param string|string[] $css_class Optional. One or more classes to add to the class list.
 462   *                                   Default empty.
 463   * @param int|WP_Post     $post      Optional. Post ID or post object. Defaults to the global `$post`.
 464   */
 465  function post_class( $css_class = '', $post = null ) {
 466      // Separates classes with a single space, collates classes for post DIV.
 467      echo 'class="' . esc_attr( implode( ' ', get_post_class( $css_class, $post ) ) ) . '"';
 468  }
 469  
 470  /**
 471   * Retrieves an array of the class names for the post container element.
 472   *
 473   * The class names are many:
 474   *
 475   *  - If the post has a post thumbnail, `has-post-thumbnail` is added as a class.
 476   *  - If the post is sticky, then the `sticky` class name is added.
 477   *  - The class `hentry` is always added to each post.
 478   *  - For each taxonomy that the post belongs to, a class will be added of the format
 479   *    `{$taxonomy}-{$slug}`, e.g. `category-foo` or `my_custom_taxonomy-bar`.
 480   *    The `post_tag` taxonomy is a special case; the class has the `tag-` prefix
 481   *    instead of `post_tag-`.
 482   *
 483   * All class names are passed through the filter, {@see 'post_class'}, followed by
 484   * `$css_class` parameter value, with the post ID as the last parameter.
 485   *
 486   * @since 2.7.0
 487   * @since 4.2.0 Custom taxonomy class names were added.
 488   *
 489   * @param string|string[] $css_class Optional. Space-separated string or array of class names
 490   *                                   to add to the class list. Default empty.
 491   * @param int|WP_Post     $post      Optional. Post ID or post object.
 492   * @return string[] Array of class names.
 493   */
 494  function get_post_class( $css_class = '', $post = null ) {
 495      $post = get_post( $post );
 496  
 497      $classes = array();
 498  
 499      if ( $css_class ) {
 500          if ( ! is_array( $css_class ) ) {
 501              $css_class = preg_split( '#\s+#', $css_class );
 502          }
 503          $classes = array_map( 'esc_attr', $css_class );
 504      } else {
 505          // Ensure that we always coerce class to being an array.
 506          $css_class = array();
 507      }
 508  
 509      if ( ! $post ) {
 510          return $classes;
 511      }
 512  
 513      $classes[] = 'post-' . $post->ID;
 514      if ( ! is_admin() ) {
 515          $classes[] = $post->post_type;
 516      }
 517      $classes[] = 'type-' . $post->post_type;
 518      $classes[] = 'status-' . $post->post_status;
 519  
 520      // Post Format.
 521      if ( post_type_supports( $post->post_type, 'post-formats' ) ) {
 522          $post_format = get_post_format( $post->ID );
 523  
 524          if ( $post_format && ! is_wp_error( $post_format ) ) {
 525              $classes[] = 'format-' . sanitize_html_class( $post_format );
 526          } else {
 527              $classes[] = 'format-standard';
 528          }
 529      }
 530  
 531      $post_password_required = post_password_required( $post->ID );
 532  
 533      // Post requires password.
 534      if ( $post_password_required ) {
 535          $classes[] = 'post-password-required';
 536      } elseif ( ! empty( $post->post_password ) ) {
 537          $classes[] = 'post-password-protected';
 538      }
 539  
 540      // Post thumbnails.
 541      if ( current_theme_supports( 'post-thumbnails' ) && has_post_thumbnail( $post->ID ) && ! is_attachment( $post ) && ! $post_password_required ) {
 542          $classes[] = 'has-post-thumbnail';
 543      }
 544  
 545      // Sticky for Sticky Posts.
 546      if ( is_sticky( $post->ID ) ) {
 547          if ( is_home() && ! is_paged() ) {
 548              $classes[] = 'sticky';
 549          } elseif ( is_admin() ) {
 550              $classes[] = 'status-sticky';
 551          }
 552      }
 553  
 554      // hentry for hAtom compliance.
 555      $classes[] = 'hentry';
 556  
 557      // All public taxonomies.
 558      $taxonomies = get_taxonomies( array( 'public' => true ) );
 559  
 560      /**
 561       * Filters the taxonomies to generate classes for each individual term.
 562       *
 563       * Default is all public taxonomies registered to the post type.
 564       *
 565       * @since 6.1.0
 566       *
 567       * @param string[] $taxonomies List of all taxonomy names to generate classes for.
 568       * @param int      $post_id    The post ID.
 569       * @param string[] $classes    An array of post class names.
 570       * @param string[] $css_class  An array of additional class names added to the post.
 571      */
 572      $taxonomies = apply_filters( 'post_class_taxonomies', $taxonomies, $post->ID, $classes, $css_class );
 573  
 574      foreach ( (array) $taxonomies as $taxonomy ) {
 575          if ( is_object_in_taxonomy( $post->post_type, $taxonomy ) ) {
 576              foreach ( (array) get_the_terms( $post->ID, $taxonomy ) as $term ) {
 577                  if ( empty( $term->slug ) ) {
 578                      continue;
 579                  }
 580  
 581                  $term_class = sanitize_html_class( $term->slug, $term->term_id );
 582                  if ( is_numeric( $term_class ) || ! trim( $term_class, '-' ) ) {
 583                      $term_class = $term->term_id;
 584                  }
 585  
 586                  // 'post_tag' uses the 'tag' prefix for backward compatibility.
 587                  if ( 'post_tag' === $taxonomy ) {
 588                      $classes[] = 'tag-' . $term_class;
 589                  } else {
 590                      $classes[] = sanitize_html_class( $taxonomy . '-' . $term_class, $taxonomy . '-' . $term->term_id );
 591                  }
 592              }
 593          }
 594      }
 595  
 596      $classes = array_map( 'esc_attr', $classes );
 597  
 598      /**
 599       * Filters the list of CSS class names for the current post.
 600       *
 601       * @since 2.7.0
 602       *
 603       * @param string[] $classes   An array of post class names.
 604       * @param string[] $css_class An array of additional class names added to the post.
 605       * @param int      $post_id   The post ID.
 606       */
 607      $classes = apply_filters( 'post_class', $classes, $css_class, $post->ID );
 608  
 609      return array_unique( $classes );
 610  }
 611  
 612  /**
 613   * Displays the class names for the body element.
 614   *
 615   * @since 2.8.0
 616   *
 617   * @param string|string[] $css_class Optional. Space-separated string or array of class names
 618   *                                   to add to the class list. Default empty.
 619   */
 620  function body_class( $css_class = '' ) {
 621      // Separates class names with a single space, collates class names for body element.
 622      echo 'class="' . esc_attr( implode( ' ', get_body_class( $css_class ) ) ) . '"';
 623  }
 624  
 625  /**
 626   * Retrieves an array of the class names for the body element.
 627   *
 628   * @since 2.8.0
 629   *
 630   * @global WP_Query $wp_query WordPress Query object.
 631   *
 632   * @param string|string[] $css_class Optional. Space-separated string or array of class names
 633   *                                   to add to the class list. Default empty.
 634   * @return string[] Array of class names.
 635   */
 636  function get_body_class( $css_class = '' ) {
 637      global $wp_query;
 638  
 639      $classes = array();
 640  
 641      if ( is_rtl() ) {
 642          $classes[] = 'rtl';
 643      }
 644  
 645      if ( is_front_page() ) {
 646          $classes[] = 'home';
 647      }
 648      if ( is_home() ) {
 649          $classes[] = 'blog';
 650      }
 651      if ( is_privacy_policy() ) {
 652          $classes[] = 'privacy-policy';
 653      }
 654      if ( is_archive() ) {
 655          $classes[] = 'archive';
 656      }
 657      if ( is_date() ) {
 658          $classes[] = 'date';
 659      }
 660      if ( is_search() ) {
 661          $classes[] = 'search';
 662          $classes[] = $wp_query->posts ? 'search-results' : 'search-no-results';
 663      }
 664      if ( is_paged() ) {
 665          $classes[] = 'paged';
 666      }
 667      if ( is_attachment() ) {
 668          $classes[] = 'attachment';
 669      }
 670      if ( is_404() ) {
 671          $classes[] = 'error404';
 672      }
 673  
 674      if ( is_singular() ) {
 675          $post      = $wp_query->get_queried_object();
 676          $post_id   = $post->ID;
 677          $post_type = $post->post_type;
 678  
 679          if ( is_page_template() ) {
 680              $classes[] = "{$post_type}-template";
 681  
 682              $template_slug  = get_page_template_slug( $post_id );
 683              $template_parts = explode( '/', $template_slug );
 684  
 685              foreach ( $template_parts as $part ) {
 686                  $classes[] = "{$post_type}-template-" . sanitize_html_class( str_replace( array( '.', '/' ), '-', basename( $part, '.php' ) ) );
 687              }
 688              $classes[] = "{$post_type}-template-" . sanitize_html_class( str_replace( '.', '-', $template_slug ) );
 689          } else {
 690              $classes[] = "{$post_type}-template-default";
 691          }
 692  
 693          if ( is_single() ) {
 694              $classes[] = 'single';
 695              if ( isset( $post->post_type ) ) {
 696                  $classes[] = 'single-' . sanitize_html_class( $post->post_type, $post_id );
 697                  $classes[] = 'postid-' . $post_id;
 698  
 699                  // Post Format.
 700                  if ( post_type_supports( $post->post_type, 'post-formats' ) ) {
 701                      $post_format = get_post_format( $post->ID );
 702  
 703                      if ( $post_format && ! is_wp_error( $post_format ) ) {
 704                          $classes[] = 'single-format-' . sanitize_html_class( $post_format );
 705                      } else {
 706                          $classes[] = 'single-format-standard';
 707                      }
 708                  }
 709              }
 710          }
 711  
 712          if ( is_attachment() ) {
 713              $mime_type   = get_post_mime_type( $post_id );
 714              $mime_prefix = array( 'application/', 'image/', 'text/', 'audio/', 'video/', 'music/' );
 715              $classes[]   = 'attachmentid-' . $post_id;
 716              $classes[]   = 'attachment-' . str_replace( $mime_prefix, '', $mime_type );
 717          } elseif ( is_page() ) {
 718              $classes[] = 'page';
 719              $classes[] = 'page-id-' . $post_id;
 720  
 721              if ( get_pages(
 722                  array(
 723                      'parent' => $post_id,
 724                      'number' => 1,
 725                  )
 726              ) ) {
 727                  $classes[] = 'page-parent';
 728              }
 729  
 730              if ( $post->post_parent ) {
 731                  $classes[] = 'page-child';
 732                  $classes[] = 'parent-pageid-' . $post->post_parent;
 733              }
 734          }
 735      } elseif ( is_archive() ) {
 736          if ( is_post_type_archive() ) {
 737              $classes[] = 'post-type-archive';
 738              $post_type = get_query_var( 'post_type' );
 739              if ( is_array( $post_type ) ) {
 740                  $post_type = reset( $post_type );
 741              }
 742              $classes[] = 'post-type-archive-' . sanitize_html_class( $post_type );
 743          } elseif ( is_author() ) {
 744              $author    = $wp_query->get_queried_object();
 745              $classes[] = 'author';
 746              if ( isset( $author->user_nicename ) ) {
 747                  $classes[] = 'author-' . sanitize_html_class( $author->user_nicename, $author->ID );
 748                  $classes[] = 'author-' . $author->ID;
 749              }
 750          } elseif ( is_category() ) {
 751              $cat       = $wp_query->get_queried_object();
 752              $classes[] = 'category';
 753              if ( isset( $cat->term_id ) ) {
 754                  $cat_class = sanitize_html_class( $cat->slug, $cat->term_id );
 755                  if ( is_numeric( $cat_class ) || ! trim( $cat_class, '-' ) ) {
 756                      $cat_class = $cat->term_id;
 757                  }
 758  
 759                  $classes[] = 'category-' . $cat_class;
 760                  $classes[] = 'category-' . $cat->term_id;
 761              }
 762          } elseif ( is_tag() ) {
 763              $tag       = $wp_query->get_queried_object();
 764              $classes[] = 'tag';
 765              if ( isset( $tag->term_id ) ) {
 766                  $tag_class = sanitize_html_class( $tag->slug, $tag->term_id );
 767                  if ( is_numeric( $tag_class ) || ! trim( $tag_class, '-' ) ) {
 768                      $tag_class = $tag->term_id;
 769                  }
 770  
 771                  $classes[] = 'tag-' . $tag_class;
 772                  $classes[] = 'tag-' . $tag->term_id;
 773              }
 774          } elseif ( is_tax() ) {
 775              $term = $wp_query->get_queried_object();
 776              if ( isset( $term->term_id ) ) {
 777                  $term_class = sanitize_html_class( $term->slug, $term->term_id );
 778                  if ( is_numeric( $term_class ) || ! trim( $term_class, '-' ) ) {
 779                      $term_class = $term->term_id;
 780                  }
 781  
 782                  $classes[] = 'tax-' . sanitize_html_class( $term->taxonomy );
 783                  $classes[] = 'term-' . $term_class;
 784                  $classes[] = 'term-' . $term->term_id;
 785              }
 786          }
 787      }
 788  
 789      if ( is_user_logged_in() ) {
 790          $classes[] = 'logged-in';
 791      }
 792  
 793      if ( is_admin_bar_showing() ) {
 794          $classes[] = 'admin-bar';
 795          $classes[] = 'no-customize-support';
 796      }
 797  
 798      if ( current_theme_supports( 'custom-background' )
 799          && ( get_background_color() !== get_theme_support( 'custom-background', 'default-color' ) || get_background_image() ) ) {
 800          $classes[] = 'custom-background';
 801      }
 802  
 803      if ( has_custom_logo() ) {
 804          $classes[] = 'wp-custom-logo';
 805      }
 806  
 807      if ( current_theme_supports( 'responsive-embeds' ) ) {
 808          $classes[] = 'wp-embed-responsive';
 809      }
 810  
 811      $page = $wp_query->get( 'page' );
 812  
 813      if ( ! $page || $page < 2 ) {
 814          $page = $wp_query->get( 'paged' );
 815      }
 816  
 817      if ( $page && $page > 1 && ! is_404() ) {
 818          $classes[] = 'paged-' . $page;
 819  
 820          if ( is_single() ) {
 821              $classes[] = 'single-paged-' . $page;
 822          } elseif ( is_page() ) {
 823              $classes[] = 'page-paged-' . $page;
 824          } elseif ( is_category() ) {
 825              $classes[] = 'category-paged-' . $page;
 826          } elseif ( is_tag() ) {
 827              $classes[] = 'tag-paged-' . $page;
 828          } elseif ( is_date() ) {
 829              $classes[] = 'date-paged-' . $page;
 830          } elseif ( is_author() ) {
 831              $classes[] = 'author-paged-' . $page;
 832          } elseif ( is_search() ) {
 833              $classes[] = 'search-paged-' . $page;
 834          } elseif ( is_post_type_archive() ) {
 835              $classes[] = 'post-type-paged-' . $page;
 836          }
 837      }
 838  
 839      if ( ! empty( $css_class ) ) {
 840          if ( ! is_array( $css_class ) ) {
 841              $css_class = preg_split( '#\s+#', $css_class );
 842          }
 843          $classes = array_merge( $classes, $css_class );
 844      } else {
 845          // Ensure that we always coerce class to being an array.
 846          $css_class = array();
 847      }
 848  
 849      $classes = array_map( 'esc_attr', $classes );
 850  
 851      /**
 852       * Filters the list of CSS body class names for the current post or page.
 853       *
 854       * @since 2.8.0
 855       *
 856       * @param string[] $classes   An array of body class names.
 857       * @param string[] $css_class An array of additional class names added to the body.
 858       */
 859      $classes = apply_filters( 'body_class', $classes, $css_class );
 860  
 861      return array_unique( $classes );
 862  }
 863  
 864  /**
 865   * Determines whether the post requires password and whether a correct password has been provided.
 866   *
 867   * @since 2.7.0
 868   *
 869   * @param int|WP_Post|null $post An optional post. Global $post used if not provided.
 870   * @return bool false if a password is not required or the correct password cookie is present, true otherwise.
 871   */
 872  function post_password_required( $post = null ) {
 873      $post = get_post( $post );
 874  
 875      if ( empty( $post->post_password ) ) {
 876          /** This filter is documented in wp-includes/post-template.php */
 877          return apply_filters( 'post_password_required', false, $post );
 878      }
 879  
 880      if ( ! isset( $_COOKIE[ 'wp-postpass_' . COOKIEHASH ] ) ) {
 881          /** This filter is documented in wp-includes/post-template.php */
 882          return apply_filters( 'post_password_required', true, $post );
 883      }
 884  
 885      require_once  ABSPATH . WPINC . '/class-phpass.php';
 886      $hasher = new PasswordHash( 8, true );
 887  
 888      $hash = wp_unslash( $_COOKIE[ 'wp-postpass_' . COOKIEHASH ] );
 889      if ( ! str_starts_with( $hash, '$P$B' ) ) {
 890          $required = true;
 891      } else {
 892          $required = ! $hasher->CheckPassword( $post->post_password, $hash );
 893      }
 894  
 895      /**
 896       * Filters whether a post requires the user to supply a password.
 897       *
 898       * @since 4.7.0
 899       *
 900       * @param bool    $required Whether the user needs to supply a password. True if password has not been
 901       *                          provided or is incorrect, false if password has been supplied or is not required.
 902       * @param WP_Post $post     Post object.
 903       */
 904      return apply_filters( 'post_password_required', $required, $post );
 905  }
 906  
 907  //
 908  // Page Template Functions for usage in Themes.
 909  //
 910  
 911  /**
 912   * The formatted output of a list of pages.
 913   *
 914   * Displays page links for paginated posts (i.e. including the `<!--nextpage-->`
 915   * Quicktag one or more times). This tag must be within The Loop.
 916   *
 917   * @since 1.2.0
 918   * @since 5.1.0 Added the `aria_current` argument.
 919   *
 920   * @global int $page
 921   * @global int $numpages
 922   * @global int $multipage
 923   * @global int $more
 924   *
 925   * @param string|array $args {
 926   *     Optional. Array or string of default arguments.
 927   *
 928   *     @type string       $before           HTML or text to prepend to each link. Default is `<p> Pages:`.
 929   *     @type string       $after            HTML or text to append to each link. Default is `</p>`.
 930   *     @type string       $link_before      HTML or text to prepend to each link, inside the `<a>` tag.
 931   *                                          Also prepended to the current item, which is not linked. Default empty.
 932   *     @type string       $link_after       HTML or text to append to each Pages link inside the `<a>` tag.
 933   *                                          Also appended to the current item, which is not linked. Default empty.
 934   *     @type string       $aria_current     The value for the aria-current attribute. Possible values are 'page',
 935   *                                          'step', 'location', 'date', 'time', 'true', 'false'. Default is 'page'.
 936   *     @type string       $next_or_number   Indicates whether page numbers should be used. Valid values are number
 937   *                                          and next. Default is 'number'.
 938   *     @type string       $separator        Text between pagination links. Default is ' '.
 939   *     @type string       $nextpagelink     Link text for the next page link, if available. Default is 'Next Page'.
 940   *     @type string       $previouspagelink Link text for the previous page link, if available. Default is 'Previous Page'.
 941   *     @type string       $pagelink         Format string for page numbers. The % in the parameter string will be
 942   *                                          replaced with the page number, so 'Page %' generates "Page 1", "Page 2", etc.
 943   *                                          Defaults to '%', just the page number.
 944   *     @type int|bool     $echo             Whether to echo or not. Accepts 1|true or 0|false. Default 1|true.
 945   * }
 946   * @return string Formatted output in HTML.
 947   */
 948  function wp_link_pages( $args = '' ) {
 949      global $page, $numpages, $multipage, $more;
 950  
 951      $defaults = array(
 952          'before'           => '<p class="post-nav-links">' . __( 'Pages:' ),
 953          'after'            => '</p>',
 954          'link_before'      => '',
 955          'link_after'       => '',
 956          'aria_current'     => 'page',
 957          'next_or_number'   => 'number',
 958          'separator'        => ' ',
 959          'nextpagelink'     => __( 'Next page' ),
 960          'previouspagelink' => __( 'Previous page' ),
 961          'pagelink'         => '%',
 962          'echo'             => 1,
 963      );
 964  
 965      $parsed_args = wp_parse_args( $args, $defaults );
 966  
 967      /**
 968       * Filters the arguments used in retrieving page links for paginated posts.
 969       *
 970       * @since 3.0.0
 971       *
 972       * @param array $parsed_args An array of page link arguments. See wp_link_pages()
 973       *                           for information on accepted arguments.
 974       */
 975      $parsed_args = apply_filters( 'wp_link_pages_args', $parsed_args );
 976  
 977      $output = '';
 978      if ( $multipage ) {
 979          if ( 'number' === $parsed_args['next_or_number'] ) {
 980              $output .= $parsed_args['before'];
 981              for ( $i = 1; $i <= $numpages; $i++ ) {
 982                  $link = $parsed_args['link_before'] . str_replace( '%', $i, $parsed_args['pagelink'] ) . $parsed_args['link_after'];
 983  
 984                  if ( $i !== $page || ! $more && 1 === $page ) {
 985                      $link = _wp_link_page( $i ) . $link . '</a>';
 986                  } elseif ( $i === $page ) {
 987                      $link = '<span class="post-page-numbers current" aria-current="' . esc_attr( $parsed_args['aria_current'] ) . '">' . $link . '</span>';
 988                  }
 989  
 990                  /**
 991                   * Filters the HTML output of individual page number links.
 992                   *
 993                   * @since 3.6.0
 994                   *
 995                   * @param string $link The page number HTML output.
 996                   * @param int    $i    Page number for paginated posts' page links.
 997                   */
 998                  $link = apply_filters( 'wp_link_pages_link', $link, $i );
 999  
1000                  // Use the custom links separator beginning with the second link.
1001                  $output .= ( 1 === $i ) ? ' ' : $parsed_args['separator'];
1002                  $output .= $link;
1003              }
1004              $output .= $parsed_args['after'];
1005          } elseif ( $more ) {
1006              $output .= $parsed_args['before'];
1007              $prev    = $page - 1;
1008              if ( $prev > 0 ) {
1009                  $link = _wp_link_page( $prev ) . $parsed_args['link_before'] . $parsed_args['previouspagelink'] . $parsed_args['link_after'] . '</a>';
1010  
1011                  /** This filter is documented in wp-includes/post-template.php */
1012                  $output .= apply_filters( 'wp_link_pages_link', $link, $prev );
1013              }
1014              $next = $page + 1;
1015              if ( $next <= $numpages ) {
1016                  if ( $prev ) {
1017                      $output .= $parsed_args['separator'];
1018                  }
1019                  $link = _wp_link_page( $next ) . $parsed_args['link_before'] . $parsed_args['nextpagelink'] . $parsed_args['link_after'] . '</a>';
1020  
1021                  /** This filter is documented in wp-includes/post-template.php */
1022                  $output .= apply_filters( 'wp_link_pages_link', $link, $next );
1023              }
1024              $output .= $parsed_args['after'];
1025          }
1026      }
1027  
1028      /**
1029       * Filters the HTML output of page links for paginated posts.
1030       *
1031       * @since 3.6.0
1032       *
1033       * @param string       $output HTML output of paginated posts' page links.
1034       * @param array|string $args   An array or query string of arguments. See wp_link_pages()
1035       *                             for information on accepted arguments.
1036       */
1037      $html = apply_filters( 'wp_link_pages', $output, $args );
1038  
1039      if ( $parsed_args['echo'] ) {
1040          echo $html;
1041      }
1042      return $html;
1043  }
1044  
1045  /**
1046   * Helper function for wp_link_pages().
1047   *
1048   * @since 3.1.0
1049   * @access private
1050   *
1051   * @global WP_Rewrite $wp_rewrite WordPress rewrite component.
1052   *
1053   * @param int $i Page number.
1054   * @return string Link.
1055   */
1056  function _wp_link_page( $i ) {
1057      global $wp_rewrite;
1058      $post       = get_post();
1059      $query_args = array();
1060  
1061      if ( 1 === $i ) {
1062          $url = get_permalink();
1063      } else {
1064          if ( ! get_option( 'permalink_structure' ) || in_array( $post->post_status, array( 'draft', 'pending' ), true ) ) {
1065              $url = add_query_arg( 'page', $i, get_permalink() );
1066          } elseif ( 'page' === get_option( 'show_on_front' ) && (int) get_option( 'page_on_front' ) === $post->ID ) {
1067              $url = trailingslashit( get_permalink() ) . user_trailingslashit( "$wp_rewrite->pagination_base/" . $i, 'single_paged' );
1068          } else {
1069              $url = trailingslashit( get_permalink() ) . user_trailingslashit( $i, 'single_paged' );
1070          }
1071      }
1072  
1073      if ( is_preview() ) {
1074  
1075          if ( ( 'draft' !== $post->post_status ) && isset( $_GET['preview_id'], $_GET['preview_nonce'] ) ) {
1076              $query_args['preview_id']    = wp_unslash( $_GET['preview_id'] );
1077              $query_args['preview_nonce'] = wp_unslash( $_GET['preview_nonce'] );
1078          }
1079  
1080          $url = get_preview_post_link( $post, $query_args, $url );
1081      }
1082  
1083      return '<a href="' . esc_url( $url ) . '" class="post-page-numbers">';
1084  }
1085  
1086  //
1087  // Post-meta: Custom per-post fields.
1088  //
1089  
1090  /**
1091   * Retrieves post custom meta data field.
1092   *
1093   * @since 1.5.0
1094   *
1095   * @param string $key Meta data key name.
1096   * @return array|string|false Array of values, or single value if only one element exists.
1097   *                            False if the key does not exist.
1098   */
1099  function post_custom( $key = '' ) {
1100      $custom = get_post_custom();
1101  
1102      if ( ! isset( $custom[ $key ] ) ) {
1103          return false;
1104      } elseif ( 1 === count( $custom[ $key ] ) ) {
1105          return $custom[ $key ][0];
1106      } else {
1107          return $custom[ $key ];
1108      }
1109  }
1110  
1111  /**
1112   * Displays a list of post custom fields.
1113   *
1114   * @since 1.2.0
1115   *
1116   * @deprecated 6.0.2 Use get_post_meta() to retrieve post meta and render manually.
1117   */
1118  function the_meta() {
1119      _deprecated_function( __FUNCTION__, '6.0.2', 'get_post_meta()' );
1120      $keys = get_post_custom_keys();
1121      if ( $keys ) {
1122          $li_html = '';
1123          foreach ( (array) $keys as $key ) {
1124              $keyt = trim( $key );
1125              if ( is_protected_meta( $keyt, 'post' ) ) {
1126                  continue;
1127              }
1128  
1129              $values = array_map( 'trim', get_post_custom_values( $key ) );
1130              $value  = implode( ', ', $values );
1131  
1132              $html = sprintf(
1133                  "<li><span class='post-meta-key'>%s</span> %s</li>\n",
1134                  /* translators: %s: Post custom field name. */
1135                  esc_html( sprintf( _x( '%s:', 'Post custom field name' ), $key ) ),
1136                  esc_html( $value )
1137              );
1138  
1139              /**
1140               * Filters the HTML output of the li element in the post custom fields list.
1141               *
1142               * @since 2.2.0
1143               *
1144               * @param string $html  The HTML output for the li element.
1145               * @param string $key   Meta key.
1146               * @param string $value Meta value.
1147               */
1148              $li_html .= apply_filters( 'the_meta_key', $html, $key, $value );
1149          }
1150  
1151          if ( $li_html ) {
1152              echo "<ul class='post-meta'>\n{$li_html}</ul>\n";
1153          }
1154      }
1155  }
1156  
1157  //
1158  // Pages.
1159  //
1160  
1161  /**
1162   * Retrieves or displays a list of pages as a dropdown (select list).
1163   *
1164   * @since 2.1.0
1165   * @since 4.2.0 The `$value_field` argument was added.
1166   * @since 4.3.0 The `$class` argument was added.
1167   *
1168   * @see get_pages()
1169   *
1170   * @param array|string $args {
1171   *     Optional. Array or string of arguments to generate a page dropdown. See get_pages() for additional arguments.
1172   *
1173   *     @type int          $depth                 Maximum depth. Default 0.
1174   *     @type int          $child_of              Page ID to retrieve child pages of. Default 0.
1175   *     @type int|string   $selected              Value of the option that should be selected. Default 0.
1176   *     @type bool|int     $echo                  Whether to echo or return the generated markup. Accepts 0, 1,
1177   *                                               or their bool equivalents. Default 1.
1178   *     @type string       $name                  Value for the 'name' attribute of the select element.
1179   *                                               Default 'page_id'.
1180   *     @type string       $id                    Value for the 'id' attribute of the select element.
1181   *     @type string       $class                 Value for the 'class' attribute of the select element. Default: none.
1182   *                                               Defaults to the value of `$name`.
1183   *     @type string       $show_option_none      Text to display for showing no pages. Default empty (does not display).
1184   *     @type string       $show_option_no_change Text to display for "no change" option. Default empty (does not display).
1185   *     @type string       $option_none_value     Value to use when no page is selected. Default empty.
1186   *     @type string       $value_field           Post field used to populate the 'value' attribute of the option
1187   *                                               elements. Accepts any valid post field. Default 'ID'.
1188   * }
1189   * @return string HTML dropdown list of pages.
1190   */
1191  function wp_dropdown_pages( $args = '' ) {
1192      $defaults = array(
1193          'depth'                 => 0,
1194          'child_of'              => 0,
1195          'selected'              => 0,
1196          'echo'                  => 1,
1197          'name'                  => 'page_id',
1198          'id'                    => '',
1199          'class'                 => '',
1200          'show_option_none'      => '',
1201          'show_option_no_change' => '',
1202          'option_none_value'     => '',
1203          'value_field'           => 'ID',
1204      );
1205  
1206      $parsed_args = wp_parse_args( $args, $defaults );
1207  
1208      $pages  = get_pages( $parsed_args );
1209      $output = '';
1210      // Back-compat with old system where both id and name were based on $name argument.
1211      if ( empty( $parsed_args['id'] ) ) {
1212          $parsed_args['id'] = $parsed_args['name'];
1213      }
1214  
1215      if ( ! empty( $pages ) ) {
1216          $class = '';
1217          if ( ! empty( $parsed_args['class'] ) ) {
1218              $class = " class='" . esc_attr( $parsed_args['class'] ) . "'";
1219          }
1220  
1221          $output = "<select name='" . esc_attr( $parsed_args['name'] ) . "'" . $class . " id='" . esc_attr( $parsed_args['id'] ) . "'>\n";
1222          if ( $parsed_args['show_option_no_change'] ) {
1223              $output .= "\t<option value=\"-1\">" . $parsed_args['show_option_no_change'] . "</option>\n";
1224          }
1225          if ( $parsed_args['show_option_none'] ) {
1226              $output .= "\t<option value=\"" . esc_attr( $parsed_args['option_none_value'] ) . '">' . $parsed_args['show_option_none'] . "</option>\n";
1227          }
1228          $output .= walk_page_dropdown_tree( $pages, $parsed_args['depth'], $parsed_args );
1229          $output .= "</select>\n";
1230      }
1231  
1232      /**
1233       * Filters the HTML output of a list of pages as a dropdown.
1234       *
1235       * @since 2.1.0
1236       * @since 4.4.0 `$parsed_args` and `$pages` added as arguments.
1237       *
1238       * @param string    $output      HTML output for dropdown list of pages.
1239       * @param array     $parsed_args The parsed arguments array. See wp_dropdown_pages()
1240       *                               for information on accepted arguments.
1241       * @param WP_Post[] $pages       Array of the page objects.
1242       */
1243      $html = apply_filters( 'wp_dropdown_pages', $output, $parsed_args, $pages );
1244  
1245      if ( $parsed_args['echo'] ) {
1246          echo $html;
1247      }
1248  
1249      return $html;
1250  }
1251  
1252  /**
1253   * Retrieves or displays a list of pages (or hierarchical post type items) in list (li) format.
1254   *
1255   * @since 1.5.0
1256   * @since 4.7.0 Added the `item_spacing` argument.
1257   *
1258   * @see get_pages()
1259   *
1260   * @global WP_Query $wp_query WordPress Query object.
1261   *
1262   * @param array|string $args {
1263   *     Optional. Array or string of arguments to generate a list of pages. See get_pages() for additional arguments.
1264   *
1265   *     @type int          $child_of     Display only the sub-pages of a single page by ID. Default 0 (all pages).
1266   *     @type string       $authors      Comma-separated list of author IDs. Default empty (all authors).
1267   *     @type string       $date_format  PHP date format to use for the listed pages. Relies on the 'show_date' parameter.
1268   *                                      Default is the value of 'date_format' option.
1269   *     @type int          $depth        Number of levels in the hierarchy of pages to include in the generated list.
1270   *                                      Accepts -1 (any depth), 0 (all pages), 1 (top-level pages only), and n (pages to
1271   *                                      the given n depth). Default 0.
1272   *     @type bool         $echo         Whether or not to echo the list of pages. Default true.
1273   *     @type string       $exclude      Comma-separated list of page IDs to exclude. Default empty.
1274   *     @type array        $include      Comma-separated list of page IDs to include. Default empty.
1275   *     @type string       $link_after   Text or HTML to follow the page link label. Default null.
1276   *     @type string       $link_before  Text or HTML to precede the page link label. Default null.
1277   *     @type string       $post_type    Post type to query for. Default 'page'.
1278   *     @type string|array $post_status  Comma-separated list or array of post statuses to include. Default 'publish'.
1279   *     @type string       $show_date    Whether to display the page publish or modified date for each page. Accepts
1280   *                                      'modified' or any other value. An empty value hides the date. Default empty.
1281   *     @type string       $sort_column  Comma-separated list of column names to sort the pages by. Accepts 'post_author',
1282   *                                      'post_date', 'post_title', 'post_name', 'post_modified', 'post_modified_gmt',
1283   *                                      'menu_order', 'post_parent', 'ID', 'rand', or 'comment_count'. Default 'post_title'.
1284   *     @type string       $title_li     List heading. Passing a null or empty value will result in no heading, and the list
1285   *                                      will not be wrapped with unordered list `<ul>` tags. Default 'Pages'.
1286   *     @type string       $item_spacing Whether to preserve whitespace within the menu's HTML. Accepts 'preserve' or 'discard'.
1287   *                                      Default 'preserve'.
1288   *     @type Walker       $walker       Walker instance to use for listing pages. Default empty which results in a
1289   *                                      Walker_Page instance being used.
1290   * }
1291   * @return void|string Void if 'echo' argument is true, HTML list of pages if 'echo' is false.
1292   */
1293  function wp_list_pages( $args = '' ) {
1294      $defaults = array(
1295          'depth'        => 0,
1296          'show_date'    => '',
1297          'date_format'  => get_option( 'date_format' ),
1298          'child_of'     => 0,
1299          'exclude'      => '',
1300          'title_li'     => __( 'Pages' ),
1301          'echo'         => 1,
1302          'authors'      => '',
1303          'sort_column'  => 'menu_order, post_title',
1304          'link_before'  => '',
1305          'link_after'   => '',
1306          'item_spacing' => 'preserve',
1307          'walker'       => '',
1308      );
1309  
1310      $parsed_args = wp_parse_args( $args, $defaults );
1311  
1312      if ( ! in_array( $parsed_args['item_spacing'], array( 'preserve', 'discard' ), true ) ) {
1313          // Invalid value, fall back to default.
1314          $parsed_args['item_spacing'] = $defaults['item_spacing'];
1315      }
1316  
1317      $output       = '';
1318      $current_page = 0;
1319  
1320      // Sanitize, mostly to keep spaces out.
1321      $parsed_args['exclude'] = preg_replace( '/[^0-9,]/', '', $parsed_args['exclude'] );
1322  
1323      // Allow plugins to filter an array of excluded pages (but don't put a nullstring into the array).
1324      $exclude_array = ( $parsed_args['exclude'] ) ? explode( ',', $parsed_args['exclude'] ) : array();
1325  
1326      /**
1327       * Filters the array of pages to exclude from the pages list.
1328       *
1329       * @since 2.1.0
1330       *
1331       * @param string[] $exclude_array An array of page IDs to exclude.
1332       */
1333      $parsed_args['exclude'] = implode( ',', apply_filters( 'wp_list_pages_excludes', $exclude_array ) );
1334  
1335      $parsed_args['hierarchical'] = 0;
1336  
1337      // Query pages.
1338      $pages = get_pages( $parsed_args );
1339  
1340      if ( ! empty( $pages ) ) {
1341          if ( $parsed_args['title_li'] ) {
1342              $output .= '<li class="pagenav">' . $parsed_args['title_li'] . '<ul>';
1343          }
1344          global $wp_query;
1345          if ( is_page() || is_attachment() || $wp_query->is_posts_page ) {
1346              $current_page = get_queried_object_id();
1347          } elseif ( is_singular() ) {
1348              $queried_object = get_queried_object();
1349              if ( is_post_type_hierarchical( $queried_object->post_type ) ) {
1350                  $current_page = $queried_object->ID;
1351              }
1352          }
1353  
1354          $output .= walk_page_tree( $pages, $parsed_args['depth'], $current_page, $parsed_args );
1355  
1356          if ( $parsed_args['title_li'] ) {
1357              $output .= '</ul></li>';
1358          }
1359      }
1360  
1361      /**
1362       * Filters the HTML output of the pages to list.
1363       *
1364       * @since 1.5.1
1365       * @since 4.4.0 `$pages` added as arguments.
1366       *
1367       * @see wp_list_pages()
1368       *
1369       * @param string    $output      HTML output of the pages list.
1370       * @param array     $parsed_args An array of page-listing arguments. See wp_list_pages()
1371       *                               for information on accepted arguments.
1372       * @param WP_Post[] $pages       Array of the page objects.
1373       */
1374      $html = apply_filters( 'wp_list_pages', $output, $parsed_args, $pages );
1375  
1376      if ( $parsed_args['echo'] ) {
1377          echo $html;
1378      } else {
1379          return $html;
1380      }
1381  }
1382  
1383  /**
1384   * Displays or retrieves a list of pages with an optional home link.
1385   *
1386   * The arguments are listed below and part of the arguments are for wp_list_pages() function.
1387   * Check that function for more info on those arguments.
1388   *
1389   * @since 2.7.0
1390   * @since 4.4.0 Added `menu_id`, `container`, `before`, `after`, and `walker` arguments.
1391   * @since 4.7.0 Added the `item_spacing` argument.
1392   *
1393   * @param array|string $args {
1394   *     Optional. Array or string of arguments to generate a page menu. See wp_list_pages() for additional arguments.
1395   *
1396   *     @type string          $sort_column  How to sort the list of pages. Accepts post column names.
1397   *                                         Default 'menu_order, post_title'.
1398   *     @type string          $menu_id      ID for the div containing the page list. Default is empty string.
1399   *     @type string          $menu_class   Class to use for the element containing the page list. Default 'menu'.
1400   *     @type string          $container    Element to use for the element containing the page list. Default 'div'.
1401   *     @type bool            $echo         Whether to echo the list or return it. Accepts true (echo) or false (return).
1402   *                                         Default true.
1403   *     @type int|bool|string $show_home    Whether to display the link to the home page. Can just enter the text
1404   *                                         you'd like shown for the home link. 1|true defaults to 'Home'.
1405   *     @type string          $link_before  The HTML or text to prepend to $show_home text. Default empty.
1406   *     @type string          $link_after   The HTML or text to append to $show_home text. Default empty.
1407   *     @type string          $before       The HTML or text to prepend to the menu. Default is '<ul>'.
1408   *     @type string          $after        The HTML or text to append to the menu. Default is '</ul>'.
1409   *     @type string          $item_spacing Whether to preserve whitespace within the menu's HTML. Accepts 'preserve'
1410   *                                         or 'discard'. Default 'discard'.
1411   *     @type Walker          $walker       Walker instance to use for listing pages. Default empty which results in a
1412   *                                         Walker_Page instance being used.
1413   * }
1414   * @return void|string Void if 'echo' argument is true, HTML menu if 'echo' is false.
1415   */
1416  function wp_page_menu( $args = array() ) {
1417      $defaults = array(
1418          'sort_column'  => 'menu_order, post_title',
1419          'menu_id'      => '',
1420          'menu_class'   => 'menu',
1421          'container'    => 'div',
1422          'echo'         => true,
1423          'link_before'  => '',
1424          'link_after'   => '',
1425          'before'       => '<ul>',
1426          'after'        => '</ul>',
1427          'item_spacing' => 'discard',
1428          'walker'       => '',
1429      );
1430      $args     = wp_parse_args( $args, $defaults );
1431  
1432      if ( ! in_array( $args['item_spacing'], array( 'preserve', 'discard' ), true ) ) {
1433          // Invalid value, fall back to default.
1434          $args['item_spacing'] = $defaults['item_spacing'];
1435      }
1436  
1437      if ( 'preserve' === $args['item_spacing'] ) {
1438          $t = "\t";
1439          $n = "\n";
1440      } else {
1441          $t = '';
1442          $n = '';
1443      }
1444  
1445      /**
1446       * Filters the arguments used to generate a page-based menu.
1447       *
1448       * @since 2.7.0
1449       *
1450       * @see wp_page_menu()
1451       *
1452       * @param array $args An array of page menu arguments. See wp_page_menu()
1453       *                    for information on accepted arguments.
1454       */
1455      $args = apply_filters( 'wp_page_menu_args', $args );
1456  
1457      $menu = '';
1458  
1459      $list_args = $args;
1460  
1461      // Show Home in the menu.
1462      if ( ! empty( $args['show_home'] ) ) {
1463          if ( true === $args['show_home'] || '1' === $args['show_home'] || 1 === $args['show_home'] ) {
1464              $text = __( 'Home' );
1465          } else {
1466              $text = $args['show_home'];
1467          }
1468          $class = '';
1469          if ( is_front_page() && ! is_paged() ) {
1470              $class = 'class="current_page_item"';
1471          }
1472          $menu .= '<li ' . $class . '><a href="' . esc_url( home_url( '/' ) ) . '">' . $args['link_before'] . $text . $args['link_after'] . '</a></li>';
1473          // If the front page is a page, add it to the exclude list.
1474          if ( 'page' === get_option( 'show_on_front' ) ) {
1475              if ( ! empty( $list_args['exclude'] ) ) {
1476                  $list_args['exclude'] .= ',';
1477              } else {
1478                  $list_args['exclude'] = '';
1479              }
1480              $list_args['exclude'] .= get_option( 'page_on_front' );
1481          }
1482      }
1483  
1484      $list_args['echo']     = false;
1485      $list_args['title_li'] = '';
1486      $menu                 .= wp_list_pages( $list_args );
1487  
1488      $container = sanitize_text_field( $args['container'] );
1489  
1490      // Fallback in case `wp_nav_menu()` was called without a container.
1491      if ( empty( $container ) ) {
1492          $container = 'div';
1493      }
1494  
1495      if ( $menu ) {
1496  
1497          // wp_nav_menu() doesn't set before and after.
1498          if ( isset( $args['fallback_cb'] ) &&
1499              'wp_page_menu' === $args['fallback_cb'] &&
1500              'ul' !== $container ) {
1501              $args['before'] = "<ul>{$n}";
1502              $args['after']  = '</ul>';
1503          }
1504  
1505          $menu = $args['before'] . $menu . $args['after'];
1506      }
1507  
1508      $attrs = '';
1509      if ( ! empty( $args['menu_id'] ) ) {
1510          $attrs .= ' id="' . esc_attr( $args['menu_id'] ) . '"';
1511      }
1512  
1513      if ( ! empty( $args['menu_class'] ) ) {
1514          $attrs .= ' class="' . esc_attr( $args['menu_class'] ) . '"';
1515      }
1516  
1517      $menu = "<{$container}{$attrs}>" . $menu . "</{$container}>{$n}";
1518  
1519      /**
1520       * Filters the HTML output of a page-based menu.
1521       *
1522       * @since 2.7.0
1523       *
1524       * @see wp_page_menu()
1525       *
1526       * @param string $menu The HTML output.
1527       * @param array  $args An array of arguments. See wp_page_menu()
1528       *                     for information on accepted arguments.
1529       */
1530      $menu = apply_filters( 'wp_page_menu', $menu, $args );
1531  
1532      if ( $args['echo'] ) {
1533          echo $menu;
1534      } else {
1535          return $menu;
1536      }
1537  }
1538  
1539  //
1540  // Page helpers.
1541  //
1542  
1543  /**
1544   * Retrieves HTML list content for page list.
1545   *
1546   * @uses Walker_Page to create HTML list content.
1547   * @since 2.1.0
1548   *
1549   * @param array $pages
1550   * @param int   $depth
1551   * @param int   $current_page
1552   * @param array $args
1553   * @return string
1554   */
1555  function walk_page_tree( $pages, $depth, $current_page, $args ) {
1556      if ( empty( $args['walker'] ) ) {
1557          $walker = new Walker_Page();
1558      } else {
1559          /**
1560           * @var Walker $walker
1561           */
1562          $walker = $args['walker'];
1563      }
1564  
1565      foreach ( (array) $pages as $page ) {
1566          if ( $page->post_parent ) {
1567              $args['pages_with_children'][ $page->post_parent ] = true;
1568          }
1569      }
1570  
1571      return $walker->walk( $pages, $depth, $args, $current_page );
1572  }
1573  
1574  /**
1575   * Retrieves HTML dropdown (select) content for page list.
1576   *
1577   * @since 2.1.0
1578   * @since 5.3.0 Formalized the existing `...$args` parameter by adding it
1579   *              to the function signature.
1580   *
1581   * @uses Walker_PageDropdown to create HTML dropdown content.
1582   * @see Walker_PageDropdown::walk() for parameters and return description.
1583   *
1584   * @param mixed ...$args Elements array, maximum hierarchical depth and optional additional arguments.
1585   * @return string
1586   */
1587  function walk_page_dropdown_tree( ...$args ) {
1588      if ( empty( $args[2]['walker'] ) ) { // The user's options are the third parameter.
1589          $walker = new Walker_PageDropdown();
1590      } else {
1591          /**
1592           * @var Walker $walker
1593           */
1594          $walker = $args[2]['walker'];
1595      }
1596  
1597      return $walker->walk( ...$args );
1598  }
1599  
1600  //
1601  // Attachments.
1602  //
1603  
1604  /**
1605   * Displays an attachment page link using an image or icon.
1606   *
1607   * @since 2.0.0
1608   *
1609   * @param int|WP_Post $post       Optional. Post ID or post object.
1610   * @param bool        $fullsize   Optional. Whether to use full size. Default false.
1611   * @param bool        $deprecated Deprecated. Not used.
1612   * @param bool        $permalink Optional. Whether to include permalink. Default false.
1613   */
1614  function the_attachment_link( $post = 0, $fullsize = false, $deprecated = false, $permalink = false ) {
1615      if ( ! empty( $deprecated ) ) {
1616          _deprecated_argument( __FUNCTION__, '2.5.0' );
1617      }
1618  
1619      if ( $fullsize ) {
1620          echo wp_get_attachment_link( $post, 'full', $permalink );
1621      } else {
1622          echo wp_get_attachment_link( $post, 'thumbnail', $permalink );
1623      }
1624  }
1625  
1626  /**
1627   * Retrieves an attachment page link using an image or icon, if possible.
1628   *
1629   * @since 2.5.0
1630   * @since 4.4.0 The `$post` parameter can now accept either a post ID or `WP_Post` object.
1631   *
1632   * @param int|WP_Post  $post      Optional. Post ID or post object.
1633   * @param string|int[] $size      Optional. Image size. Accepts any registered image size name, or an array
1634   *                                of width and height values in pixels (in that order). Default 'thumbnail'.
1635   * @param bool         $permalink Optional. Whether to add permalink to image. Default false.
1636   * @param bool         $icon      Optional. Whether the attachment is an icon. Default false.
1637   * @param string|false $text      Optional. Link text to use. Activated by passing a string, false otherwise.
1638   *                                Default false.
1639   * @param array|string $attr      Optional. Array or string of attributes. Default empty.
1640   * @return string HTML content.
1641   */
1642  function wp_get_attachment_link( $post = 0, $size = 'thumbnail', $permalink = false, $icon = false, $text = false, $attr = '' ) {
1643      $_post = get_post( $post );
1644  
1645      if ( empty( $_post ) || ( 'attachment' !== $_post->post_type ) || ! wp_get_attachment_url( $_post->ID ) ) {
1646          return __( 'Missing Attachment' );
1647      }
1648  
1649      $url = wp_get_attachment_url( $_post->ID );
1650  
1651      if ( $permalink ) {
1652          $url = get_attachment_link( $_post->ID );
1653      }
1654  
1655      if ( $text ) {
1656          $link_text = $text;
1657      } elseif ( $size && 'none' !== $size ) {
1658          $link_text = wp_get_attachment_image( $_post->ID, $size, $icon, $attr );
1659      } else {
1660          $link_text = '';
1661      }
1662  
1663      if ( '' === trim( $link_text ) ) {
1664          $link_text = $_post->post_title;
1665      }
1666  
1667      if ( '' === trim( $link_text ) ) {
1668          $link_text = esc_html( pathinfo( get_attached_file( $_post->ID ), PATHINFO_FILENAME ) );
1669      }
1670  
1671      /**
1672       * Filters the list of attachment link attributes.
1673       *
1674       * @since 6.2.0
1675       *
1676       * @param array $attributes An array of attributes for the link markup,
1677       *                          keyed on the attribute name.
1678       * @param int   $id         Post ID.
1679       */
1680      $attributes = apply_filters( 'wp_get_attachment_link_attributes', array( 'href' => $url ), $_post->ID );
1681  
1682      $link_attributes = '';
1683      foreach ( $attributes as $name => $value ) {
1684          $value            = 'href' === $name ? esc_url( $value ) : esc_attr( $value );
1685          $link_attributes .= ' ' . esc_attr( $name ) . "='" . $value . "'";
1686      }
1687  
1688      $link_html = "<a$link_attributes>$link_text</a>";
1689  
1690      /**
1691       * Filters a retrieved attachment page link.
1692       *
1693       * @since 2.7.0
1694       * @since 5.1.0 Added the `$attr` parameter.
1695       *
1696       * @param string       $link_html The page link HTML output.
1697       * @param int|WP_Post  $post      Post ID or object. Can be 0 for the current global post.
1698       * @param string|int[] $size      Requested image size. Can be any registered image size name, or
1699       *                                an array of width and height values in pixels (in that order).
1700       * @param bool         $permalink Whether to add permalink to image. Default false.
1701       * @param bool         $icon      Whether to include an icon.
1702       * @param string|false $text      If string, will be link text.
1703       * @param array|string $attr      Array or string of attributes.
1704       */
1705      return apply_filters( 'wp_get_attachment_link', $link_html, $post, $size, $permalink, $icon, $text, $attr );
1706  }
1707  
1708  /**
1709   * Wraps attachment in paragraph tag before content.
1710   *
1711   * @since 2.0.0
1712   *
1713   * @param string $content
1714   * @return string
1715   */
1716  function prepend_attachment( $content ) {
1717      $post = get_post();
1718  
1719      if ( empty( $post->post_type ) || 'attachment' !== $post->post_type ) {
1720          return $content;
1721      }
1722  
1723      if ( wp_attachment_is( 'video', $post ) ) {
1724          $meta = wp_get_attachment_metadata( get_the_ID() );
1725          $atts = array( 'src' => wp_get_attachment_url() );
1726          if ( ! empty( $meta['width'] ) && ! empty( $meta['height'] ) ) {
1727              $atts['width']  = (int) $meta['width'];
1728              $atts['height'] = (int) $meta['height'];
1729          }
1730          if ( has_post_thumbnail() ) {
1731              $atts['poster'] = wp_get_attachment_url( get_post_thumbnail_id() );
1732          }
1733          $p = wp_video_shortcode( $atts );
1734      } elseif ( wp_attachment_is( 'audio', $post ) ) {
1735          $p = wp_audio_shortcode( array( 'src' => wp_get_attachment_url() ) );
1736      } else {
1737          $p = '<p class="attachment">';
1738          // Show the medium sized image representation of the attachment if available, and link to the raw file.
1739          $p .= wp_get_attachment_link( 0, 'medium', false );
1740          $p .= '</p>';
1741      }
1742  
1743      /**
1744       * Filters the attachment markup to be prepended to the post content.
1745       *
1746       * @since 2.0.0
1747       *
1748       * @see prepend_attachment()
1749       *
1750       * @param string $p The attachment HTML output.
1751       */
1752      $p = apply_filters( 'prepend_attachment', $p );
1753  
1754      return "$p\n$content";
1755  }
1756  
1757  //
1758  // Misc.
1759  //
1760  
1761  /**
1762   * Retrieves protected post password form content.
1763   *
1764   * @since 1.0.0
1765   *
1766   * @param int|WP_Post $post Optional. Post ID or WP_Post object. Default is global $post.
1767   * @return string HTML content for password form for password protected post.
1768   */
1769  function get_the_password_form( $post = 0 ) {
1770      $post   = get_post( $post );
1771      $label  = 'pwbox-' . ( empty( $post->ID ) ? rand() : $post->ID );
1772      $output = '<form action="' . esc_url( site_url( 'wp-login.php?action=postpass', 'login_post' ) ) . '" class="post-password-form" method="post">
1773      <p>' . __( 'This content is password protected. To view it please enter your password below:' ) . '</p>
1774      <p><label for="' . $label . '">' . __( 'Password:' ) . ' <input name="post_password" id="' . $label . '" type="password" spellcheck="false" size="20" /></label> <input type="submit" name="Submit" value="' . esc_attr_x( 'Enter', 'post password form' ) . '" /></p></form>
1775      ';
1776  
1777      /**
1778       * Filters the HTML output for the protected post password form.
1779       *
1780       * If modifying the password field, please note that the WordPress database schema
1781       * limits the password field to 255 characters regardless of the value of the
1782       * `minlength` or `maxlength` attributes or other validation that may be added to
1783       * the input.
1784       *
1785       * @since 2.7.0
1786       * @since 5.8.0 Added the `$post` parameter.
1787       *
1788       * @param string  $output The password form HTML output.
1789       * @param WP_Post $post   Post object.
1790       */
1791      return apply_filters( 'the_password_form', $output, $post );
1792  }
1793  
1794  /**
1795   * Determines whether the current post uses a page template.
1796   *
1797   * This template tag allows you to determine if you are in a page template.
1798   * You can optionally provide a template filename or array of template filenames
1799   * and then the check will be specific to that template.
1800   *
1801   * For more information on this and similar theme functions, check out
1802   * the {@link https://developer.wordpress.org/themes/basics/conditional-tags/
1803   * Conditional Tags} article in the Theme Developer Handbook.
1804   *
1805   * @since 2.5.0
1806   * @since 4.2.0 The `$template` parameter was changed to also accept an array of page templates.
1807   * @since 4.7.0 Now works with any post type, not just pages.
1808   *
1809   * @param string|string[] $template The specific template filename or array of templates to match.
1810   * @return bool True on success, false on failure.
1811   */
1812  function is_page_template( $template = '' ) {
1813      if ( ! is_singular() ) {
1814          return false;
1815      }
1816  
1817      $page_template = get_page_template_slug( get_queried_object_id() );
1818  
1819      if ( empty( $template ) ) {
1820          return (bool) $page_template;
1821      }
1822  
1823      if ( $template === $page_template ) {
1824          return true;
1825      }
1826  
1827      if ( is_array( $template ) ) {
1828          if ( ( in_array( 'default', $template, true ) && ! $page_template )
1829              || in_array( $page_template, $template, true )
1830          ) {
1831              return true;
1832          }
1833      }
1834  
1835      return ( 'default' === $template && ! $page_template );
1836  }
1837  
1838  /**
1839   * Gets the specific template filename for a given post.
1840   *
1841   * @since 3.4.0
1842   * @since 4.7.0 Now works with any post type, not just pages.
1843   *
1844   * @param int|WP_Post $post Optional. Post ID or WP_Post object. Default is global $post.
1845   * @return string|false Page template filename. Returns an empty string when the default page template
1846   *                      is in use. Returns false if the post does not exist.
1847   */
1848  function get_page_template_slug( $post = null ) {
1849      $post = get_post( $post );
1850  
1851      if ( ! $post ) {
1852          return false;
1853      }
1854  
1855      $template = get_post_meta( $post->ID, '_wp_page_template', true );
1856  
1857      if ( ! $template || 'default' === $template ) {
1858          return '';
1859      }
1860  
1861      return $template;
1862  }
1863  
1864  /**
1865   * Retrieves formatted date timestamp of a revision (linked to that revisions's page).
1866   *
1867   * @since 2.6.0
1868   *
1869   * @param int|WP_Post $revision Revision ID or revision object.
1870   * @param bool        $link     Optional. Whether to link to revision's page. Default true.
1871   * @return string|false i18n formatted datetimestamp or localized 'Current Revision'.
1872   */
1873  function wp_post_revision_title( $revision, $link = true ) {
1874      $revision = get_post( $revision );
1875  
1876      if ( ! $revision ) {
1877          return $revision;
1878      }
1879  
1880      if ( ! in_array( $revision->post_type, array( 'post', 'page', 'revision' ), true ) ) {
1881          return false;
1882      }
1883  
1884      /* translators: Revision date format, see https://www.php.net/manual/datetime.format.php */
1885      $datef = _x( 'F j, Y @ H:i:s', 'revision date format' );
1886      /* translators: %s: Revision date. */
1887      $autosavef = __( '%s [Autosave]' );
1888      /* translators: %s: Revision date. */
1889      $currentf = __( '%s [Current Revision]' );
1890  
1891      $date      = date_i18n( $datef, strtotime( $revision->post_modified ) );
1892      $edit_link = get_edit_post_link( $revision->ID );
1893      if ( $link && current_user_can( 'edit_post', $revision->ID ) && $edit_link ) {
1894          $date = "<a href='$edit_link'>$date</a>";
1895      }
1896  
1897      if ( ! wp_is_post_revision( $revision ) ) {
1898          $date = sprintf( $currentf, $date );
1899      } elseif ( wp_is_post_autosave( $revision ) ) {
1900          $date = sprintf( $autosavef, $date );
1901      }
1902  
1903      return $date;
1904  }
1905  
1906  /**
1907   * Retrieves formatted date timestamp of a revision (linked to that revisions's page).
1908   *
1909   * @since 3.6.0
1910   *
1911   * @param int|WP_Post $revision Revision ID or revision object.
1912   * @param bool        $link     Optional. Whether to link to revision's page. Default true.
1913   * @return string|false gravatar, user, i18n formatted datetimestamp or localized 'Current Revision'.
1914   */
1915  function wp_post_revision_title_expanded( $revision, $link = true ) {
1916      $revision = get_post( $revision );
1917  
1918      if ( ! $revision ) {
1919          return $revision;
1920      }
1921  
1922      if ( ! in_array( $revision->post_type, array( 'post', 'page', 'revision' ), true ) ) {
1923          return false;
1924      }
1925  
1926      $author = get_the_author_meta( 'display_name', $revision->post_author );
1927      /* translators: Revision date format, see https://www.php.net/manual/datetime.format.php */
1928      $datef = _x( 'F j, Y @ H:i:s', 'revision date format' );
1929  
1930      $gravatar = get_avatar( $revision->post_author, 24 );
1931  
1932      $date      = date_i18n( $datef, strtotime( $revision->post_modified ) );
1933      $edit_link = get_edit_post_link( $revision->ID );
1934      if ( $link && current_user_can( 'edit_post', $revision->ID ) && $edit_link ) {
1935          $date = "<a href='$edit_link'>$date</a>";
1936      }
1937  
1938      $revision_date_author = sprintf(
1939          /* translators: Post revision title. 1: Author avatar, 2: Author name, 3: Time ago, 4: Date. */
1940          __( '%1$s %2$s, %3$s ago (%4$s)' ),
1941          $gravatar,
1942          $author,
1943          human_time_diff( strtotime( $revision->post_modified_gmt ) ),
1944          $date
1945      );
1946  
1947      /* translators: %s: Revision date with author avatar. */
1948      $autosavef = __( '%s [Autosave]' );
1949      /* translators: %s: Revision date with author avatar. */
1950      $currentf = __( '%s [Current Revision]' );
1951  
1952      if ( ! wp_is_post_revision( $revision ) ) {
1953          $revision_date_author = sprintf( $currentf, $revision_date_author );
1954      } elseif ( wp_is_post_autosave( $revision ) ) {
1955          $revision_date_author = sprintf( $autosavef, $revision_date_author );
1956      }
1957  
1958      /**
1959       * Filters the formatted author and date for a revision.
1960       *
1961       * @since 4.4.0
1962       *
1963       * @param string  $revision_date_author The formatted string.
1964       * @param WP_Post $revision             The revision object.
1965       * @param bool    $link                 Whether to link to the revisions page, as passed into
1966       *                                      wp_post_revision_title_expanded().
1967       */
1968      return apply_filters( 'wp_post_revision_title_expanded', $revision_date_author, $revision, $link );
1969  }
1970  
1971  /**
1972   * Displays a list of a post's revisions.
1973   *
1974   * Can output either a UL with edit links or a TABLE with diff interface, and
1975   * restore action links.
1976   *
1977   * @since 2.6.0
1978   *
1979   * @param int|WP_Post $post Optional. Post ID or WP_Post object. Default is global $post.
1980   * @param string      $type 'all' (default), 'revision' or 'autosave'
1981   */
1982  function wp_list_post_revisions( $post = 0, $type = 'all' ) {
1983      $post = get_post( $post );
1984  
1985      if ( ! $post ) {
1986          return;
1987      }
1988  
1989      // $args array with (parent, format, right, left, type) deprecated since 3.6.
1990      if ( is_array( $type ) ) {
1991          $type = ! empty( $type['type'] ) ? $type['type'] : $type;
1992          _deprecated_argument( __FUNCTION__, '3.6.0' );
1993      }
1994  
1995      $revisions = wp_get_post_revisions( $post->ID );
1996  
1997      if ( ! $revisions ) {
1998          return;
1999      }
2000  
2001      $rows = '';
2002      foreach ( $revisions as $revision ) {
2003          if ( ! current_user_can( 'read_post', $revision->ID ) ) {
2004              continue;
2005          }
2006  
2007          $is_autosave = wp_is_post_autosave( $revision );
2008          if ( ( 'revision' === $type && $is_autosave ) || ( 'autosave' === $type && ! $is_autosave ) ) {
2009              continue;
2010          }
2011  
2012          $rows .= "\t<li>" . wp_post_revision_title_expanded( $revision ) . "</li>\n";
2013      }
2014  
2015      echo "<div class='hide-if-js'><p>" . __( 'JavaScript must be enabled to use this feature.' ) . "</p></div>\n";
2016  
2017      echo "<ul class='post-revisions hide-if-no-js'>\n";
2018      echo $rows;
2019      echo '</ul>';
2020  }
2021  
2022  /**
2023   * Retrieves the parent post object for the given post.
2024   *
2025   * @since 5.7.0
2026   *
2027   * @param int|WP_Post|null $post Optional. Post ID or WP_Post object. Default is global $post.
2028   * @return WP_Post|null Parent post object, or null if there isn't one.
2029   */
2030  function get_post_parent( $post = null ) {
2031      $wp_post = get_post( $post );
2032      return ! empty( $wp_post->post_parent ) ? get_post( $wp_post->post_parent ) : null;
2033  }
2034  
2035  /**
2036   * Returns whether the given post has a parent post.
2037   *
2038   * @since 5.7.0
2039   *
2040   * @param int|WP_Post|null $post Optional. Post ID or WP_Post object. Default is global $post.
2041   * @return bool Whether the post has a parent post.
2042   */
2043  function has_post_parent( $post = null ) {
2044      return (bool) get_post_parent( $post );
2045  }


Generated : Tue Dec 24 08:20:01 2024 Cross-referenced by PHPXref