User Picker?

I decided to dive in and try this myself. I found the fields folder with each of the field types implemented in its own tidy file.

I cloned the post.php into a user.php and modified it to read the users from the DB. It actually worked … a couple of times, and then I broke it. I tried everything to get it working again but it doesn’t seem to actually execute the get_options method.

Here is the user.php code

if ( !class_exists( 'RWMB_User_Field' ) )
{
	class RWMB_User_Field extends RWMB_Field
	{

		static function admin_enqueue_scripts()
		{
			RWMB_Select_Advanced_Field::admin_enqueue_scripts();
		}

		static function html( $meta, $field )
		{
			$field['options'] = self::get_options( $field );
			switch ( $field['field_type'] )
			{
				case 'select':
					return RWMB_Select_Field::html( $meta, $field );
				case 'select_advanced':
				default:
					return RWMB_Select_Advanced_Field::html( $meta, $field );
			}
		}

		static function normalize_field( $field )
		{
			$field['query_args'] = wp_parse_args( $field['query_args'], array(
					'role'      => $field['role'],
			) );

			switch ( $field['field_type'] )
			{
				case 'select':
					return RWMB_Select_Field::normalize_field( $field );
					break;
				case 'select_advanced':
				default:
					return RWMB_Select_Advanced_Field::normalize_field( $field );
			}
		}

		static function meta( $user_id, $saved, $field )
		{
			return RWMB_Select_Field::meta( $user_id, $saved, $field );
		}

		static function save( $new, $old, $user_id, $field )
		{
			return RWMB_Select_Field::save( $new, $old, $user_id, $field );
		}

		static function get_options( $field )
		{
			$query = new WP_User_Query( $field['query_args'] );
			if ( ! empty( $query->results ) ) {
				foreach ( $query->results as $user)
				{
					$options[$user->ID] = $user->display_name;
				}
			} else {
				$options = array();
			}
			return $options;
		}
	}
}

And here is the section I added to demo.php

// USER
			array(
				'name'    => __( 'User', 'rwmb' ),
				'id'      => "{$prefix}users",
				'type'    => 'user',
				'role'    => 'student',

				// Field type, either 'select' or 'select_advanced' (default)
				'field_type' => 'select_advanced',
			),

I wonder if anyone can spot some obvious goof-up. Thanks!

I am guessing that the problem is that my entry in demo.php is not getting instantiated properly. So the thing I need to understand is: how does an associative-array from demo.php get matched up with one of those php files in the field folder? To find out, I’m gonna trace my way through this labyrinth, one passage way at a time.

Each of those field files contains an extension of the RWMB_Field class (for example RWMB_Post_Field). So you’d think that eventually the arrays in demo.php are going to become instances of those classes.

The code in demo.php is one function that creates a gigantic associative array with an entry called ‘fields’, which contain a generic array containing a list of field arrays. This function is hooked to a filter and when it is invoked it returns this massive array of arrays.

When the rwmb_register_meta_boxes function in Init.php is called, it runs all the filter hooks attached to ‘rwmb_meta_boxes’, one of which just happens to be the contents of the demo.php file. Each of the objects returned by apply_filters() is passed to the RW_Meta_Box constructor (in metabox.php).

This constructor must be where the magic happens. The first call is

$this->meta_box = self::normalize( $meta_box );

Normalize merges a several more parameters to $meta_box, and calls …

$meta_box['fields'] = self::normalize_fields( $meta_box['fields'] );

Which then normalizes each of the field arrays with a 3 step process.

First it merges a bunch of new entries into the array. Then it calls a static function in the class represented by this array:

$field = call_user_func( array( self::get_class_name( $field ), 'normalize_field' ),

Inside of get_class_name, is the code that creates the name of the class that implements this field conversion

$class = 'RWMB_' . ucwords( $type ) . '_Field';

So call_user_func is actually calling RWMB_Type_Field::normalize_field. Pretty slick!

Finally, step 3, it recursively does the same thing on any fields arrays found within the current field array.

Okay … so now I understand how the field files work. They are never actually instantiated. Instead, the ‘type’ field is used to construct the name of a static function of the class in the file.

Nice system, but I still can’t get it to work for my implementation of a user-picker ??

Actually the code posted above works fine, although it needs some tweaking. The problem was that I shot myself in the foot during debugging.

This plugin has a really cool way of automatically including all the field files in the project.

foreach ( glob( RWMB_FIELDS_DIR . '*.php' ) as $file )
	{
		require_once $file;
	}

Not knowing this I renamed a version of my user.php file, thinking that would prevent it from being loaded. But instead, it prevented my new version of user.php from being loaded.

The good news is that I learned a lot about this plugin along the way, and a lot about php too.