Cum pot încărca un șablon de pagină dintr-un plugin?

Aceasta este o combinație între răspunsul de mai sus și comentariile care au funcționat pentru mine în final.

Funcția pentru a adăuga plugin-ul în lista de șabloane disponibile:

function wpse255804_add_page_template ($templates) {
    $templates['my-custom-template.php'] = 'Șablonul meu';
    return $templates;
    }
add_filter ('theme_page_templates', 'wpse255804_add_page_template');

Funcția pentru a direcționa șablonul către directorul corespunzător din cadrul plugin-ului:

function wpse255804_redirect_page_template ($template) {
    $post = get_post();
    $page_template = get_post_meta( $post->ID, '_wp_page_template', true );
    if ('my-custom-template.php' == basename ($page_template))
        $template = WP_PLUGIN_DIR . '/mypluginname/my-custom-template.php';
    return $template;
    }
add_filter ('page_template', 'wpse255804_redirect_page_template');

Mulțumesc pentru ajutor. Am modificat puțin codul pentru a funcționa cu versiunea actuală de WordPress. De asemenea, l-am adaptat pentru a suporta mai mult de un șablon personalizat.

Sunt sigur că există o metodă mai bună de a face asta, dar a funcționat pentru mine.

/**
 * Încărcare Șablon cu Plugin
 */
function yourname_add_page_template ($templates) {
    $templates['page-one.php'] = 'titlu aici Unu';
    $templates['page-two.php'] = 'titlu aici Doi';
    $templates['page-three.php'] = 'titlu aici Trei';
    return $templates;
}
add_filter ('theme_page_templates', 'yourname_add_page_template');

function yourname_redirect_page_template ($template) {
    $post = get_post();
    $page_template = get_post_meta( $post->ID, '_wp_page_template', true );
    if ('page-one.php' == basename ($page_template)) {
        $template = WP_PLUGIN_DIR . '/pluginname/templates/page-one.php';
        return $template;
    }
    elseif ('page-two.php' == basename ($page_template)) {
        $template = WP_PLUGIN_DIR . '/pluginname/templates/page-two.php';
        return $template;
    }
    elseif ('page-three.php' == basename ($page_template)) {
        $template = WP_PLUGIN_DIR . '/pluginname/templates/page-three.php';
        return $template;
    }
}
add_filter ('page_template', 'yourname_redirect_page_template');

Din codex:

<?php 
   $templates = get_page_templates();
   foreach ( $templates as $template_name => $template_filename ) {
       echo "$template_name ($template_filename)<br />";
   }
?>

Apoi puteți folosi șabloanele curente și să le adăugați programatic la orice doriți.

Fragmentul de cod de mai jos este foarte bine gândit, va încerca să găsească un șablon în plugin și dacă nu îl găsește acolo, va încerca să îl obțină din tema.

define( 'MY_PLUGIN_DIR', plugin_dir_path( __FILE __ ) );
define( 'MY_PLUGIN_TEMPLATE_DIR', MY_PLUGIN_DIR . '/templates/' );

add_filter( 'template_include', 'ibenic_include_from_plugin', 99 );

function ibenic_include_from_plugin( $template ) {

    $new_template = '';

    $provided_template_array = explode( '/', $template );

    // Acesta ne va oferi archive.php
    $new_template = end( $provided_template_array );

    // Definește șabloanele single și archive pentru tipul de post personalizat 'portfolio'
    if( is_singular('portfolio') ) {
        $new_template = 'single-portfolio.php';
    }

    if( is_post_type_archive( 'portfolio' ) ) {
        $new_template = 'archive-portfolio.php';
    }

    $plugin_template = MY_PLUGIN_TEMPLATE_DIR . $new_template;

    if( file_exists( $plugin_template ) ) {
    return $plugin_template;
    }

    return $template;
}

Sursa: https://www.ibenic.com/include-or-override-wordpress-templates/

Iată o actualizare pentru 2022: Mai jos, acest cod va adăuga un șablon la lista de șabloane de pagină și îl va înregistra în fișierele pluginului tău

// ------------înregistrează șablonul în lista de șabloane de pagină------------
function register_custom_template_list ($templates) {
  // ------------înregistrează numele afișat al șablonului cu numele fișierului------------
  $templates['my-template.php'] = 'Numele Șablonului Meu';
  // ------------returnează lista de șabloane de pagină cu noua adăugare------------
  return $templates;
}
// ------------leagă șablonul de pagină la lista de șabloane------------
add_filter('theme_page_templates', 'register_custom_template_list');

// ------------înregistrează șablonul de pagină în fișier------------
function render_custom_template_archive ($template) {
  // ------------obține atributele paginii editate curent------------
  $post = get_post();
  $page_template = get_post_meta( $post->ID, '_wp_page_template', true );
  // ------------verifică dacă șablonul selectat este pentru șablonul personalizat------------
  if (basename ($page_template) == 'my-template.php'){
    // ------------înregistrează fișierul șablonului de pagină la pagină------------
    $template = dirname(__DIR__).'/calea_catre/my-template.php';
    // ------------randeză conținutul șablonului personalizat------------
    return $template;
  } else {
    // ------------returnează șablonul selectat dacă șablonul personalizat nu este selectat------------
    return $template;
  }
}
// ------------leagă șablonul de pagină la fișier------------
add_filter('page_template', 'render_custom_template_archive');

Acum că WordPress acceptă utilizarea a ceea ce era denumit în mod tradițional ca șabloane de pagini (Page Templates) cu alte tipuri de postări, pare că ar fi util un exemplu actualizat care funcționează atât pentru postări și tipuri personalizate de postări, cât și pentru pagini.

/*
    Plugin Name: Example Plugin Templates
    Plugin URI: 
    Description: Încărcare șabloane de pagini (sau tipuri de postări) dintr-un plugin
    Version: 0.1
    Requires at least: 6.0
    Requires PHP: 7
    Author: t31os
    Author URI: 
    License: GPL v2 or later
    License URI: https://www.gnu.org/licenses/gpl-2.0.html
*/
namespace t31os\Plugin;

if( !defined('ABSPATH') )
    exit;

class Plugin_Templates {
    
    private $types;
    private $args;
    private $folder;
    private $templates = [
         'template-name-1.php' => 'Șablon Plugin 1'
        ,'template-name-2.php' => 'Șablon Plugin 2'
        ,'template-name-3.php' => 'Șablon Plugin 3'
    ];
    
    public function __construct() {
        // Hook târziu pentru a permite pluginurilor/temelor să înregistreze tipurile de postări
        add_action( 'init', [$this, 'on_init'], 5000 );
    }
    public function on_init() {
        
        // Filtre hook-uri, de ce nu!
        $this->args      = apply_filters( 'my_plugin_template_type_args', [ 'public' => true ] );
        $this->folder    = apply_filters( 'my_plugin_template_directory', __DIR__ . '/templates/' );
        $this->templates = apply_filters( 'my_plugin_template_file_list', $this->templates );
        // Setează tipurile de postări 
        $this->types     = get_post_types( $this->args );
        
        // Nu folosim șabloane de pagini cu atașamente
        unset( $this->types['attachment'] );
        
        // Adaugă fișiere personalizate în lista de șabloane
        add_filter( 'theme_templates', [$this,'add_plugin_templates'], 1000, 4 );
        
        // Dacă pagina este unul dintre tipuri
        if( isset( $this->types['page'] ) )
            add_filter( 'page_template', [$this,'set_plugin_page_template'], 1000, 3 );
        
        // Și gestionează alte tipuri de postări
        add_filter( 'single_template', [$this,'set_plugin_type_template'], 1000, 3 );   
    }
    public function add_plugin_templates( $post_templates, $obj, $post, $post_type ) {
        
        if( !isset( $this->types[$post_type] ) )
            return $post_templates;
        
        foreach( $this->templates as $file => $name )
            $post_templates[$file] = $name;
        
        return $post_templates;
    }
    private function is_plugin_template( $file ) {
        return (bool) isset( $this->templates[$file] ) && file_exists( $this->folder . $file );
    }
    public function set_plugin_page_template( $template, $type, $templates ) {
        
        if( !isset( $templates[0] ) )
            return $template;
        
        if( $this->is_plugin_template( $templates[0] ) )
            return $this->folder . $templates[0];
        
        return $template;
    }
    public function set_plugin_type_template( $template, $type, $templates ) {
        
        if( !isset( $templates[0] ) || 'single' !== $type )
            return $template;
        
        if( $this->is_plugin_template( $templates[0] ) )
            return $this->folder . $templates[0];
        
        return $template;
    }
    // Funcție simplă pentru depanare / verificare valori
    private function pre( $s ) {
        printf( '<pre>%s</pre>', print_r( $s, true ) );
    }
}
new Plugin_Templates;

Am încercat să nu fiu prea abstract și să păstrez logica destul de simplă, dacă există probleme, adăugați un comentariu.

<?php load_template( $_template_file, $require_once ) ?>

Aceasta este din primul rezultat al căutării Google pentru "load template from plugin". Te rugăm să încerci să găsești singur răspunsurile înainte de a întreba aici.