'classic', // Accepted values: 'classic', 'block'.
* 'allow-users' => false,
*
* @param boolean To override the settings return an array with the above keys.
*/
$settings = apply_filters( 'classic_editor_plugin_settings', false );
if ( is_array( $settings ) ) {
return array(
'editor' => ( isset( $settings['editor'] ) && $settings['editor'] === 'block' ) ? 'block' : 'classic',
'allow-users' => ! empty( $settings['allow-users'] ),
'hide-settings-ui' => true,
);
}
if ( ! empty( self::$settings ) && $refresh === 'no' ) {
return self::$settings;
}
if ( is_multisite() ) {
$defaults = array(
'editor' => get_network_option( null, 'classic-editor-replace' ) === 'block' ? 'block' : 'classic',
'allow-users' => false,
);
/**
* Filters the default network options.
*
* @param array $defaults The default options array. See `classic_editor_plugin_settings` for supported keys and values.
*/
$defaults = apply_filters( 'classic_editor_network_default_settings', $defaults );
if ( get_network_option( null, 'classic-editor-allow-sites' ) !== 'allow' ) {
// Per-site settings are disabled. Return default network options nad hide the settings UI.
$defaults['hide-settings-ui'] = true;
return $defaults;
}
// Override with the site options.
$editor_option = get_option( 'classic-editor-replace' );
$allow_users_option = get_option( 'classic-editor-allow-users' );
if ( $editor_option ) {
$defaults['editor'] = $editor_option;
}
if ( $allow_users_option ) {
$defaults['allow-users'] = ( $allow_users_option === 'allow' );
}
$editor = ( isset( $defaults['editor'] ) && $defaults['editor'] === 'block' ) ? 'block' : 'classic';
$allow_users = ! empty( $defaults['allow-users'] );
} else {
$allow_users = ( get_option( 'classic-editor-allow-users' ) === 'allow' );
$option = get_option( 'classic-editor-replace' );
// Normalize old options.
if ( $option === 'block' || $option === 'no-replace' ) {
$editor = 'block';
} else {
// empty( $option ) || $option === 'classic' || $option === 'replace'.
$editor = 'classic';
}
}
// Override the defaults with the user options.
if ( ( ! isset( $GLOBALS['pagenow'] ) || $GLOBALS['pagenow'] !== 'options-writing.php' ) && $allow_users ) {
$user_options = get_user_option( 'classic-editor-settings' );
if ( $user_options === 'block' || $user_options === 'classic' ) {
$editor = $user_options;
}
}
self::$settings = array(
'editor' => $editor,
'hide-settings-ui' => false,
'allow-users' => $allow_users,
);
return self::$settings;
}
private static function is_classic( $post_id = 0 ) {
if ( ! $post_id ) {
$post_id = self::get_edited_post_id();
}
if ( $post_id ) {
$settings = self::get_settings();
if ( $settings['allow-users'] && ! isset( $_GET['classic-editor__forget'] ) ) {
$which = get_post_meta( $post_id, 'classic-editor-remember', true );
if ( $which ) {
// The editor choice will be "remembered" when the post is opened in either the classic or the block editor.
if ( 'classic-editor' === $which ) {
return true;
} elseif ( 'block-editor' === $which ) {
return false;
}
}
return ( ! self::has_blocks( $post_id ) );
}
}
if ( isset( $_GET['classic-editor'] ) ) {
return true;
}
return false;
}
/**
* Get the edited post ID (early) when loading the Edit Post screen.
*/
private static function get_edited_post_id() {
if (
! empty( $_GET['post'] ) &&
! empty( $_GET['action'] ) &&
$_GET['action'] === 'edit' &&
! empty( $GLOBALS['pagenow'] ) &&
$GLOBALS['pagenow'] === 'post.php'
) {
return (int) $_GET['post']; // post_ID
}
return 0;
}
public static function register_settings() {
// Add an option to Settings -> Writing
register_setting( 'writing', 'classic-editor-replace', array(
'sanitize_callback' => array( __CLASS__, 'validate_option_editor' ),
) );
register_setting( 'writing', 'classic-editor-allow-users', array(
'sanitize_callback' => array( __CLASS__, 'validate_option_allow_users' ),
) );
$allowed_options = array(
'writing' => array(
'classic-editor-replace',
'classic-editor-allow-users'
),
);
if ( function_exists( 'add_allowed_options' ) ) {
add_allowed_options( $allowed_options );
} else {
add_option_whitelist( $allowed_options );
}
$heading_1 = __( 'Default editor for all users', 'classic-editor' );
$heading_2 = __( 'Allow users to switch editors', 'classic-editor' );
add_settings_field( 'classic-editor-1', $heading_1, array( __CLASS__, 'settings_1' ), 'writing' );
add_settings_field( 'classic-editor-2', $heading_2, array( __CLASS__, 'settings_2' ), 'writing' );
}
public static function save_user_settings( $user_id ) {
if (
isset( $_POST['classic-editor-user-settings'] ) &&
isset( $_POST['classic-editor-replace'] ) &&
wp_verify_nonce( $_POST['classic-editor-user-settings'], 'allow-user-settings' )
) {
$user_id = (int) $user_id;
if ( $user_id !== get_current_user_id() && ! current_user_can( 'edit_user', $user_id ) ) {
return;
}
$editor = self::validate_option_editor( $_POST['classic-editor-replace'] );
update_user_option( $user_id, 'classic-editor-settings', $editor );
}
}
/**
* Validate
*/
public static function validate_option_editor( $value ) {
if ( $value === 'block' ) {
return 'block';
}
return 'classic';
}
public static function validate_option_allow_users( $value ) {
if ( $value === 'allow' ) {
return 'allow';
}
return 'disallow';
}
public static function settings_1() {
$settings = self::get_settings( 'refresh' );
?>
ID, 'classic-editor' );
}
}
/**
* Remember when the block editor was used to edit a post.
*/
public static function remember_block_editor( $editor_settings, $post ) {
$post_type = get_post_type( $post );
if ( $post_type && self::can_edit_post_type( $post_type ) ) {
self::remember( $post->ID, 'block-editor' );
}
return $editor_settings;
}
private static function remember( $post_id, $editor ) {
if ( get_post_meta( $post_id, 'classic-editor-remember', true ) !== $editor ) {
update_post_meta( $post_id, 'classic-editor-remember', $editor );
}
}
/**
* Choose which editor to use for a post.
*
* Passes through `$which_editor` for block editor (it's sets to `true` but may be changed by another plugin).
*
* @uses `use_block_editor_for_post` filter.
*
* @param boolean $use_block_editor True for block editor, false for classic editor.
* @param WP_Post $post The post being edited.
* @return boolean True for block editor, false for classic editor.
*/
public static function choose_editor( $use_block_editor, $post ) {
$settings = self::get_settings();
$editors = self::get_enabled_editors_for_post( $post );
// If no editor is supported, pass through `$use_block_editor`.
if ( ! $editors['block_editor'] && ! $editors['classic_editor'] ) {
return $use_block_editor;
}
// Open the default editor when no $post and for "Add New" links,
// or the alternate editor when the user is switching editors.
if ( empty( $post->ID ) || $post->post_status === 'auto-draft' ) {
if (
( $settings['editor'] === 'classic' && ! isset( $_GET['classic-editor__forget'] ) ) || // Add New
( isset( $_GET['classic-editor'] ) && isset( $_GET['classic-editor__forget'] ) ) // Switch to classic editor when no draft post.
) {
$use_block_editor = false;
}
} elseif ( self::is_classic( $post->ID ) ) {
$use_block_editor = false;
}
// Enforce the editor if set by plugins.
if ( $use_block_editor && ! $editors['block_editor'] ) {
$use_block_editor = false;
} elseif ( ! $use_block_editor && ! $editors['classic_editor'] && $editors['block_editor'] ) {
$use_block_editor = true;
}
return $use_block_editor;
}
/**
* Keep the `classic-editor` query arg through redirects when saving posts.
*/
public static function redirect_location( $location ) {
if (
isset( $_REQUEST['classic-editor'] ) ||
( isset( $_POST['_wp_http_referer'] ) && strpos( $_POST['_wp_http_referer'], '&classic-editor' ) !== false )
) {
$location = add_query_arg( 'classic-editor', '', $location );
}
return $location;
}
/**
* Keep the `classic-editor` query arg when looking at revisions.
*/
public static function get_edit_post_link( $url ) {
$settings = self::get_settings();
if ( isset( $_REQUEST['classic-editor'] ) || $settings['editor'] === 'classic' ) {
$url = add_query_arg( 'classic-editor', '', $url );
}
return $url;
}
public static function add_meta_box( $post_type, $post ) {
$editors = self::get_enabled_editors_for_post( $post );
if ( ! $editors['block_editor'] || ! $editors['classic_editor'] ) {
// Editors cannot be switched.
return;
}
$id = 'classic-editor-switch-editor';
$title = __( 'Editor', 'classic-editor' );
$callback = array( __CLASS__, 'do_meta_box' );
$args = array(
'__back_compat_meta_box' => true,
);
add_meta_box( $id, $title, $callback, null, 'side', 'default', $args );
}
public static function do_meta_box( $post ) {
$edit_url = get_edit_post_link( $post->ID, 'raw' );
// Switching to block editor.
$edit_url = remove_query_arg( 'classic-editor', $edit_url );
// Forget the previous value when going to a specific editor.
$edit_url = add_query_arg( 'classic-editor__forget', '', $edit_url );
?>
__( 'Switch to classic editor', 'classic-editor' ) )
);
}
/**
* Add a link to the settings on the Plugins screen.
*/
public static function add_settings_link( $links, $file ) {
$settings = self::get_settings();
if ( $file === 'classic-editor/classic-editor.php' && ! $settings['hide-settings-ui'] && current_user_can( 'manage_options' ) ) {
if ( current_filter() === 'plugin_action_links' ) {
$url = admin_url( 'options-writing.php#classic-editor-options' );
} else {
$url = admin_url( '/network/settings.php#classic-editor-options' );
}
// Prevent warnings in PHP 7.0+ when a plugin uses this filter incorrectly.
$links = (array) $links;
$links[] = sprintf( '%s', $url, __( 'Settings', 'classic-editor' ) );
}
return $links;
}
private static function can_edit_post_type( $post_type ) {
$can_edit = false;
if ( function_exists( 'gutenberg_can_edit_post_type' ) ) {
$can_edit = gutenberg_can_edit_post_type( $post_type );
} elseif ( function_exists( 'use_block_editor_for_post_type' ) ) {
$can_edit = use_block_editor_for_post_type( $post_type );
}
return $can_edit;
}
/**
* Checks which editors are enabled for the post type.
*
* @param string $post_type The post type.
* @return array Associative array of the editors and whether they are enabled for the post type.
*/
private static function get_enabled_editors_for_post_type( $post_type ) {
if ( isset( self::$supported_post_types[ $post_type ] ) ) {
return self::$supported_post_types[ $post_type ];
}
$classic_editor = post_type_supports( $post_type, 'editor' );
$block_editor = self::can_edit_post_type( $post_type );
$editors = array(
'classic_editor' => $classic_editor,
'block_editor' => $block_editor,
);
/**
* Filters the editors that are enabled for the post type.
*
* @param array $editors Associative array of the editors and whether they are enabled for the post type.
* @param string $post_type The post type.
*/
$editors = apply_filters( 'classic_editor_enabled_editors_for_post_type', $editors, $post_type );
self::$supported_post_types[ $post_type ] = $editors;
return $editors;
}
/**
* Checks which editors are enabled for the post.
*
* @param WP_Post $post The post object.
* @return array Associative array of the editors and whether they are enabled for the post.
*/
private static function get_enabled_editors_for_post( $post ) {
$post_type = get_post_type( $post );
if ( ! $post_type ) {
return array(
'classic_editor' => false,
'block_editor' => false,
);
}
$editors = self::get_enabled_editors_for_post_type( $post_type );
/**
* Filters the editors that are enabled for the post.
*
* @param array $editors Associative array of the editors and whether they are enabled for the post.
* @param WP_Post $post The post object.
*/
return apply_filters( 'classic_editor_enabled_editors_for_post', $editors, $post );
}
/**
* Adds links to the post/page screens to edit any post or page in
* the classic editor or block editor.
*
* @param array $actions Post actions.
* @param WP_Post $post Edited post.
* @return array Updated post actions.
*/
public static function add_edit_links( $actions, $post ) {
// This is in Gutenberg, don't duplicate it.
if ( array_key_exists( 'classic', $actions ) ) {
unset( $actions['classic'] );
}
if ( ! array_key_exists( 'edit', $actions ) ) {
return $actions;
}
$edit_url = get_edit_post_link( $post->ID, 'raw' );
if ( ! $edit_url ) {
return $actions;
}
$editors = self::get_enabled_editors_for_post( $post );
// Do not show the links if only one editor is available.
if ( ! $editors['classic_editor'] || ! $editors['block_editor'] ) {
return $actions;
}
// Forget the previous value when going to a specific editor.
$edit_url = add_query_arg( 'classic-editor__forget', '', $edit_url );
// Build the edit actions. See also: WP_Posts_List_Table::handle_row_actions().
$title = _draft_or_post_title( $post->ID );
// Link to the block editor.
$url = remove_query_arg( 'classic-editor', $edit_url );
$text = _x( 'Edit (block editor)', 'Editor Name', 'classic-editor' );
/* translators: %s: post title */
$label = sprintf( __( 'Edit “%s” in the block editor', 'classic-editor' ), $title );
$edit_block = sprintf( '%s', esc_url( $url ), esc_attr( $label ), $text );
// Link to the classic editor.
$url = add_query_arg( 'classic-editor', '', $edit_url );
$text = _x( 'Edit (classic editor)', 'Editor Name', 'classic-editor' );
/* translators: %s: post title */
$label = sprintf( __( 'Edit “%s” in the classic editor', 'classic-editor' ), $title );
$edit_classic = sprintf( '%s', esc_url( $url ), esc_attr( $label ), $text );
$edit_actions = array(
'classic-editor-block' => $edit_block,
'classic-editor-classic' => $edit_classic,
);
// Insert the new Edit actions instead of the Edit action.
$edit_offset = array_search( 'edit', array_keys( $actions ), true );
array_splice( $actions, $edit_offset, 1, $edit_actions );
return $actions;
}
/**
* Show the editor that will be used in a "post state" in the Posts list table.
*/
public static function add_post_state( $post_states, $post ) {
if ( get_post_status( $post ) === 'trash' ) {
return $post_states;
}
$editors = self::get_enabled_editors_for_post( $post );
if ( ! $editors['classic_editor'] && ! $editors['block_editor'] ) {
return $post_states;
} elseif ( $editors['classic_editor'] && ! $editors['block_editor'] ) {
// Forced to classic editor.
$state = '' . _x( 'classic editor', 'Editor Name', 'classic-editor' ) . '';
} elseif ( ! $editors['classic_editor'] && $editors['block_editor'] ) {
// Forced to block editor.
$state = '' . _x( 'block editor', 'Editor Name', 'classic-editor' ) . '';
} else {
$last_editor = get_post_meta( $post->ID, 'classic-editor-remember', true );
if ( $last_editor ) {
$is_classic = ( $last_editor === 'classic-editor' );
} elseif ( ! empty( $post->post_content ) ) {
$is_classic = ! self::has_blocks( $post->post_content );
} else {
$settings = self::get_settings();
$is_classic = ( $settings['editor'] === 'classic' );
}
$state = $is_classic ? _x( 'Classic editor', 'Editor Name', 'classic-editor' ) : _x( 'Block editor', 'Editor Name', 'classic-editor' );
}
// Fix PHP 7+ warnings if another plugin returns unexpected type.
$post_states = (array) $post_states;
$post_states['classic-editor-plugin'] = $state;
return $post_states;
}
public static function add_edit_php_inline_style() {
?>
post_content;
}
}
return false !== strpos( (string) $post, '