Inputfield / InputfieldWrapper

Attributes

attr($key, $value)

Get or set an HTML attribute. The primary method for working with input attributes.

$f->attr('name', 'email');
$f->attr('value', 'default@example.com');
$name = $f->attr('name'); // get

// Set multiple attributes at once
$f->attr([
    'name' => 'email',
    'value' => 'default@example.com',
    'placeholder' => 'you@example.com',
]);

// Set name and id to the same value
$f->attr('name+id', 'email');

// Get all attributes
$attrs = $f->attr(true);

Passing false as the value removes most boolean attributes when setting them. To remove any attribute explicitly, use $f->removeAttr('attributeName').

val($value)

Shortcut getter/setter for the value attribute.

$current = $f->val();      // get
$f->val('new value');      // set

name() / id() / class()

Chainable getter/setter methods:

$f->name('email')->id('input-email')->class('uk-input');
$name = $f->name(); // get

Labels and text

All support magic property set/get (this is the most commonly used syntax):

$f->label = 'Email Address';
$f->description = 'Enter your primary email';
$f->notes = 'We will not share your email';
$f->icon = 'envelope';

Collapsed state

Controls how the Inputfield renders in the admin. Set via the collapsed property using one of the constants below:

$f->collapsed = Inputfield::collapsedYes;
$f->collapsed = Inputfield::collapsedBlankAjax;

Visibility and layout

showIf and requiredIf enable the conditional visibility and required state of an Inputfield. These are often referred to as Inputfield dependencies. These properties accept ProcessWire selector strings referencing other field names in the same form. Note that they support a reduced set of selector features, so test and verify before assuming a showIf/requiredIf condition works properly. Supported operators include =, !=, <', <=, >, >=, *=. OR conditions are also supported for field name and value.

// show only when Inputfield `info_type` field has value 'contact'.
$f->showIf = 'info_type=contact';

// required only when condition is met ($f->required must be true)
$f->requiredIf = 'info_type=contact';
$f->required = true;

// percentage width for 2+ Inputfields in a row (10-100; 0 treated as 100)
$f->columnWidth = 50;

When matching Page reference fields in a showIf or requiredIf selector, note that you are matching by page ID.

Field context properties

When an Inputfield is used in the page editor (via a Field on a Template), ProcessWire populates three runtime properties that provide context about where the Inputfield is being used. These are set automatically by the core. You don't typically set them yourself, but it's occasionally useful to read them and adjust behavior based on context.

The hasFieldtype property has three states:

• null — Undetermined, not yet or not applicable (default for standalone forms).
• false — Explicitly a standalone form (FormBuilder module sets this, for example).
• Fieldtype object — Connected to a Field on a Page (page editor context).

Some Inputfield types adjust their behavior based on hasFieldtype. For example, to provide additional features or configuration when used in the page editor.

if($f->hasFieldtype) { 
    // Fieldtype instance, likely page editor context
    $field = $f->hasField; // Field instance
    $page = $f->hasPage; // Page instance
}

Skip label

Controls label rendering. Use skipLabel constants:

$f->skipLabel = Inputfield::skipLabelHeader; // no label rendered
$f->skipLabel = Inputfield::skipLabelMarkup; // allow <strong> etc. in label

Class manipulation

$f->addClass('uk-input uk-form-large');      // add to input element
$f->addClass('highlight', 'wrapClass');      // add to .Inputfield wrapper element
$f->addClass('wrap:card, header:card-head'); // formatted element-specific classes

if($f->hasClass('required')) { ... }

$f->removeClass('old-class');

The $property argument accepts: 'class', 'wrapClass', 'headerClass', 'contentClass'. The short names 'input', 'wrap', 'header', and 'content' are also accepted where class-property names are parsed.

You can also use fluent class methods for common wrapper elements:

$f->wrapClass('card');          // add class to outer .Inputfield wrapper
$f->headerClass('card-head');   // add class to .InputfieldHeader
$f->contentClass('card-body');  // add class to .InputfieldContent

$wrapClass = $f->wrapClass();   // get current wrapper classes

Processing and validation

Common form-handling pattern:

/** @var InputfieldForm $form */
$form = $modules->get('InputfieldForm');

/** @var InputfieldEmail $f */
$f = $modules->get('InputfieldEmail');
$f->attr('name', 'email');
$f->label = 'Your email';
$f->required = true;
$form->add($f);

/** @var InputfieldSubmit $f */
$f = $modules->get('InputfieldSubmit');
$f->attr('name', 'submit_send');
$f->value = 'Send';
$form->add($f);

if($input->post('submit_send')) {
    $form->processInput($input->post);
    if(count($form->getErrors())) {
        // re-render form with errors
    } else {
        /** @var InputfieldEmail $f */
        $f = $form->getChildByName('email');
        $email = $f->value;
        // handle submission
        // ...
        $session->location('/success/page/url');
    }
}

echo $form->render();

More modern form handling pattern:

/** @var InputfieldForm $form */
$form = $modules->get('InputfieldForm');

$f = $form->InputfieldEmail;
$f->attr('name', 'email');
$f->label = 'Your email';
$f->required = true;
$form->add($f);

$f = $form->InputfieldSubmit;
$f->attr('name', 'submit_send');
$f->val('Send');
$form->add($f);

if($form->isSubmitted('submit_send')) {
    if($form->process()) {
        $email = $form->getValueByName('email');
        // handle submission
        $session->location('/success/page/url');
    } else {
        // re-render form with errors
    }
}

echo $form->render();

process()

Process an InputfieldForm using the form's configured method (post by default, or get when $form->attr('method', 'get')). Returns true when processing completed with no errors, or false when validation errors were recorded.

if($form->process()) {
    // form processed successfully
} else {
    $errors = $form->getErrors();
    $errorFields = $form->getErrorInputfields();
}

This is often more convenient than processInput() at the form level because it does not require passing $input->post or $input->get, and it gives you a success/failure boolean directly.

CSRF protection

InputfieldForm has CSRF protection enabled by default for POST forms.

$form = $modules->get('InputfieldForm');
$form->protectCSRF = true; // default

When the form renders, it automatically includes the CSRF token input. When you call $form->process() or $form->processInput($input->post), the token is validated. If the token is invalid, ProcessWire throws a WireException.

Disable CSRF protection only for trusted/internal forms:

$form->protectCSRF = false;

CSRF protection is applied to POST forms, not GET forms.

processInput(WireInputData $input)

Process submitted input data for this Inputfield and populate its value.

$f->processInput($input->post);
$value = $f->val(); // now contains the processed value

isEmpty()

Returns true if the Inputfield's current value is considered empty.

error($text) / getErrors($clear) / clearErrors()

$f->error('Value is not valid');
$errors = $f->getErrors();       // array of error strings
$errors = $f->getErrors(true);   // get and clear
$f->clearErrors();

Rendering

echo $f->render();        // render as an editable input
echo $f->renderValue();   // render as a value display (no input)

editable($setEditable)

Get or set whether the Inputfield renders in editable or value-display mode.

$f->editable(false); // lock; renderValue() used instead of render()
$isEditable = $f->editable();

Hierarchy

$parent = $f->parent();       // get parent InputfieldWrapper
$parents = $f->getParents();  // all ancestor wrappers
$root = $f->getRootParent();  // top-level wrapper
$form = $f->getForm();        // nearest InputfieldForm ancestor

These properties are recognized by AdminThemeUikit to control visual presentation: