Translate new created pages from page field on the fly

[Can]

Hey folks,

 

I use InputfieldPageAutocomplete a lot, but because the website is dual language it's a little awkward when creating new tags with this field.

While looking if anyone else had a solution for this I found out that InputfieldPage is still not activating language urls https://github.com/ryancramerdesign/ProcessWire/issues/889 but couldn't find a solution how to translate new entries on the fly.

 

Maybe someone comes up with a nicer solution, but for now it works for me. I copied InputfieldPage.module to /site/modules/ and added a few lines of code.

Now when creating a new tag using for example autocomplete field, I just enter "foo:bar" where foo is default (english) and bar is german title. So as you can see, right now it's quite static..

Here my complete file, I commented my additions with "added by Can"

  Reveal hidden contents

<?php

/**
 * An Inputfield for handling relational Page inputs
 *
 * Delegates the actual input control to a user-defined Inputfield derived from InputfieldSelect
 * 
 * @method PageArray getSelectablePages(Page $page)
 * @method PageArray findPagesCode(Page $page)
 * 
 * Can be accessed from $this or from $field:
 * 
 * @property int $template_id
 * @property int $parent_id
 * @property string $inputfield
 * @property string $labelFieldName Field name to use for label (note: this will be "." if $labelFieldFormat is in use).
 * @property string $labelFieldFormat Formatting string for $page->getMarkup() as alternative to $labelFieldName
 * @property string $findPagesCode
 * @property string $findPagesSelector
 * @property int|bool $addable
 * @property int|bool $allowUnpub
 * 
 */
class InputfieldPage extends Inputfield implements ConfigurableModule {

	protected $inputfieldWidget = null;

	protected static $defaultInputfieldClasses = array(
		// default options
		'InputfieldSelect',
		'InputfieldSelectMultiple',
		'InputfieldCheckboxes',
		'InputfieldRadios', 
		'InputfieldAsmSelect',
		'InputfieldPageListSelect', 
		'InputfieldPageAutocomplete',
		); 

	protected static $defaultConfig = array(
		'parent_id' => 0,
		'template_id' => 0,
		'inputfield' => '', 
		'labelFieldName' => '',
		'labelFieldFormat' => '',
		'findPagesCode' => '',
		'findPagesSelector' => '',
		'addable' => 0,
		'allowUnpub' => 0, // This option configured by FieldtypePage:Advanced
		); 

	/**
	 * Contains true when this module is in configuration state (via it's getConfigInputfields function)
	 *
	 */
	protected $configMode = false;

	/**
	 * True when processInput is currently processing
	 * 
	 */
	protected $processInputMode = false;

	/**
	 * PageArray of pages that were added in the request
	 *
	 */
	protected $pagesAdded; 
	
	protected $classesAdded = array();
	
	public static function getModuleInfo() {
		return array(
			'title' => 'Page',
			'version' => 106,
			'summary' => 'Select one or more pages',
			'permanent' => true, 
			);
	}

	public function __construct() {
		$this->set('inputfieldClasses', self::$defaultInputfieldClasses); 
		parent::__construct();
	}

	public function init() {
		foreach(self::$defaultConfig as $key => $value) {
			$this->set($key, $value);
		}
		$this->attr('value', new PageArray()); 
		parent::init();
	}
	
	public function addClass($class, $property = 'class') {
		if($property == 'class') {
			$this->classesAdded[] = $class; 
		}
		return parent::addClass($class, $property); 
	}
	
	public function setAttribute($key, $value) {

		if($key == 'value') { 
			if(is_string($value) || is_int($value)) {
				// setting the value attr from a string, whether 1234 or 123|446|789

				if(ctype_digit("$value")) {
					// i.e. "1234"
					$a = new PageArray();
					$page = wire('pages')->get((int) $value);
					if($page->id) $a->add($page);
					$value = $a; 

				} else if(strpos($value, '|') !== false) {
					// i.e. 123|456|789
					$a = new PageArray();
					foreach(explode('|', $value) as $id) {
						if(!ctype_digit("$id")) continue; 
						$page = wire('pages')->get((int) $id);
						if($page->id) $a->add($page);
					}
					$value = $a; 
				} else {
					// unrecognized format
				}
			}

		}
		return parent::setAttribute($key, $value);
	}

	/**
	 * Is the given $page valid for the given $field?
	 * 
	 * Note that this validates all but findPagesCode (eval) based page selections. 
	 * This is primarily for use by FieldtypePage, but kept here since the config options
	 * it uses to check are part of this module's config. 
	 * 
	 * If false is returned and given an $editPage, a reason for the false will be populated
	 * to the $editPage->_isValidPage property. 
	 * 
	 * @param Page $page
	 * @param Field|string|int $field Field instance of field name (string) or ID
	 * @param Page $editPage Page being edited
	 * @return bool
	 * @throws WireException
	 * 
	 */
	public static function isValidPage(Page $page, $field, Page $editPage = null) {
		
		if(!$field instanceof Field) $field = wire('fields')->get($field);
		if(!$field instanceof Field) throw new WireException('isValidPage requires a valid Field or field name');
		if($editPage && $page->id == $editPage->id) {
			$editPage->set('_isValidPage', "Page is referencing itself and circular page reference not allowed");
			return false; // prevent circular reference
		}
		if(wire('pages')->cloning) {
			return true; // bypass check when clong is active
		}

		$valid = true;
		
		if($field->findPagesSelector) { 
			$selector = $field->findPagesSelector; 
			if($editPage) $selector = self::getFindPagesSelector($editPage, $selector); 
			if(!$page->matches($selector)) {
				if($editPage) $editPage->set('_isValidPage', "Page $page does not match findPagesSelector: $selector"); 
				$valid = false;
			}
		} 
		
		if($field->findPagesCode) {
			// TODO: we don't currently validate these
		} 

		if($field->parent_id && $field->parent_id != $page->parent_id) {
			if(version_compare(PHP_VERSION, '5.3.8') >= 0) {
				if(is_subclass_of($field->inputfield, 'InputfieldPageListSelection')) {
					// parent_id represents a root parent
					$rootParent = wire('pages')->get($field->parent_id); 
					if(!$page->parents()->has($rootParent)) $valid = false;
				} else {
					// parent_id represents a direct parent
					$valid = false;
				}
				if(!$valid && $editPage) $editPage->set('_isValidPage', "Page $page does not have required parent $field->parent_id"); 
			} else {
				// PHP version prior to 5.3.8
				$reflector = new ReflectionClass($field->inputfield); 
				$valid = $reflector->implementsInterface('InputfieldPageListSelection'); 
			}
		}
		
		if($field->template_id && $page->template->id != $field->template_id) {
			$valid = false;
			if($editPage) $editPage->set('_isValidPage', "Page $page does not have required template $field->template_id"); 
		}
		
		return $valid;
	}

	/**
	 * Execute the findPagesCode
	 * 
	 * @param Page $page The page being edited
	 * @return PageArray (hopefully)
	 * 
	 */
	protected function ___findPagesCode(Page $page) {
		if(empty($this->findPagesCode)) return new PageArray();
		$pages = $this->wire('pages'); // so that it is locally scoped to the eval
		return eval($this->findPagesCode);
	}

	public function has($key) {
		// ensures it accepts any config value (like those for delegate inputfields)
		return true; 
	}

	/**
	 * Return PageArray of selectable pages for this input
	 * 
	 * @param Page $page The Page being edited
	 * @return PageArray
	 * 
	 */
	public function ___getSelectablePages(Page $page) {

		$statusUnder = $this->allowUnpub ? Page::statusTrash : Page::statusUnpublished; 

		if($this->configMode) {
			$children = new PageArray();

		} else if($this->findPagesSelector) { 
			// a find() selector
			$instance = $this->processInputMode ? $this : null;
			$selector = self::getFindPagesSelector($page, $this->findPagesSelector, $instance);
			$children = $this->pages->find($selector); 

		} else if($this->findPagesCode) {
			// php statement that returns a PageArray or a Page (to represent a parent)
			$children = $this->findPagesCode($page);
			if($children instanceof Page) $children = $children->children(); // @teppokoivula

		} else if($this->parent_id) {
			$parent = $this->fuel('pages')->get($this->parent_id); 
			if($parent) $children = $this->template_id ? $parent->children("templates_id={$this->template_id}, check_access=0, status<$statusUnder") : $parent->children("check_access=0, status<$statusUnder");

		} else if($this->template_id) {
			$children = $this->pages->find("templates_id={$this->template_id}, check_access=0, status<$statusUnder"); 

		} else {
			$children = new PageArray();
		}
		
		if($children->has($page)) $children->remove($page); // don't allow page being edited to be selected

		return $children; 
	} 

	/**
	 * Populate any variables in findPagesSelector
	 * 
	 * @param Page $page
	 * @param string $selector
	 * @param Inputfield $inputfield
	 * @return string
	 *
	 */
	protected static function getFindPagesSelector(Page $page, $selector, $inputfield = null) {
	
		// if an $inputfield is passed in, then we want to retrieve dependent values directly
		// from the form, rather than from the $page
		if($inputfield) {
			// locate the $form
			$n = 0;
			$form = $inputfield;
			do {
				$form = $form->getParent();
				if(++$n > 10) break;
			} while($form && $form->className() != 'InputfieldForm'); 
		} else $form = null;

		// find variables identified by: page.field or page.field.subfield
		if(strpos($selector, '=page.') !== false) {
			preg_match_all('/=page\.([_.a-zA-Z0-9]+)/', $selector, $matches); 
			foreach($matches[0] as $key => $tag) {
				$field = $matches[1][$key];	
				$subfield = '';
				if(strpos($field, '.')) list($field, $subfield) = explode('.', $field); 
				$value = null;
				if($form && (!$subfield || $subfield == 'id')) {
					// attempt to get value from the form, to account for ajax changes that would not yet be reflected on the page
					$in = $form->get($field); 
					if($in) $value = $in->attr('value');
				}
				if(is_null($value)) $value = $page->get($field); 
				if(is_object($value) && $subfield) $value = $value->$subfield;
				if(is_array($value)) $value = implode('|', $value); 
				$selector = str_replace($tag, "=$value", $selector); 
			}
		}
		return $selector; 
	}

	public function getInputfield() {

		if($this->inputfieldWidget && ((string) $this->inputfieldWidget) == $this->inputfield) return $this->inputfieldWidget; 

		$inputfield = $this->wire('modules')->get($this->inputfield);
		if(!$inputfield) return null;
		if($this->derefAsPage) $inputfield->set('maxSelectedItems', 1); 

		$page = $this->page; 
		$process = $this->wire('process'); 
		if($process && $process instanceof WirePageEditor) $page = $process->getPage();

		$inputfield->attr('name', $this->attr('name')); 
		$inputfield->attr('id', $this->attr('id')); 
		$inputfield->label = $this->label;
		$inputfield->description = $this->description;

		if($this->collapsed == Inputfield::collapsedYesAjax || 
			($this->collapsed == Inputfield::collapsedBlankAjax && $this->isEmpty())) {
			// quick exit when possible due to ajax field, and not being time to render or process it
			if($this->getParent()) {
				// limit only to inputfields that have a parent, to keep out of other form contexts like Lister
				$renderInputfieldAjax = $this->wire('input')->get('renderInputfieldAjax');
				$processInputfieldAjax = $this->wire('input')->post('processInputfieldAjax');
				if(!is_array($processInputfieldAjax)) $processInputfieldAjax = array();
				if($renderInputfieldAjax != $this->attr('id') && !in_array($this->attr('id'), $processInputfieldAjax)) {
					$this->inputfieldWidget = $inputfield;
					return $inputfield;
				}
			}
		}

		if(method_exists($inputfield, 'addOption')) {
			$children = $this->getSelectablePages($page);
			if($children) foreach($children as $child) {
				$label = '';
				if(strlen($this->labelFieldFormat) && $this->labelFieldName == '.') {
					$label = $child->getMarkup($this->labelFieldFormat);
				} else if($this->labelFieldName === '.') {
					// skip
				} else if($this->labelFieldName) {
					$label = $child->get($this->labelFieldName);
				}
				if(!strlen($label)) $label = $child->name; 
				if($child->hasStatus(Page::statusUnpublished)) $label .= ' ' . $this->_('(unpublished)');
				$inputfield->addOption($child->id, $label);
			}
		} else {
			if($this->parent_id) {
				$inputfield->parent_id = $this->parent_id;
			} else if($this->findPagesCode) {
				// @teppokoivula: use findPagesCode to return single parent page
				$child = $this->findPagesCode($page);
				if($child instanceof Page) $inputfield->parent_id = $child->id; 
			}
			if($this->template_id) $inputfield->template_id = $this->template_id; 
			if($this->findPagesSelector) $inputfield->findPagesSelector = $this->findPagesSelector; 
			if(strlen($this->labelFieldFormat) && $this->labelFieldName === '.') {
				$inputfield->labelFieldName = $this->labelFieldFormat;
				$inputfield->labelFieldFormat = $this->labelFieldFormat;
			} else {
				$inputfield->labelFieldName = $this->labelFieldName == '.' ? 'name' : $this->labelFieldName;
				$inputfield->labelFieldFormat = '';
			}				
		}

		$ids = array();
		$value = $this->attr('value'); 
		if($value instanceof Page) $inputfield->attr('value', $value->id); // derefAsPage
			else if($value instanceof PageArray) foreach($value as $v) $inputfield->attr('value', $v->id); // derefAsPageArray

		// pass long any relevant configuration items
		foreach($this->data as $key => $value) {
			if(in_array($key, array('value', 'collapsed')) || array_key_exists($key, self::$defaultConfig)) continue; 
			if($key == 'required' && empty($this->data['defaultValue'])) continue; // for default value support with InputfieldSelect
			$inputfield->set($key, $value); 
		}

		$this->inputfieldWidget = $inputfield;
		return $inputfield; 
	}
	
	public function renderReady(Inputfield $parent = null, $renderValueMode = false) {
		parent::renderReady($parent, $renderValueMode);
		$inputfield = $this->getInputfield();
		if(!$inputfield) {
			$this->error("Not fully configured  / currently nonfunctional");
			return false;
		}
		$this->addClass('InputfieldNoFocus', 'wrapClass');
		return $inputfield->renderReady($this, $renderValueMode);
	}

	public function ___render() {

		$inputfield = $this->getInputfield();
		if(!$inputfield) return $this->name;
		
		$classes = InputfieldWrapper::getClasses();
		$class = $inputfield->className();
		if(isset($classes[$class]['item_content'])) $class .= " " . $classes[$class]['item_content'];
		foreach($this->classesAdded as $addClass) $inputfield->addClass($addClass);

		$out = 	"\n<div class='$class'>";
		$out .= $inputfield->render();
		$out .= $this->renderAddable();
		
		if($this->findPagesSelector) {
			$selector = $this->wire('sanitizer')->entities($this->findPagesSelector); 
			$formatName = '';
			if(strlen($this->labelFieldFormat) && $this->labelFieldName === '.') {
				/** @var ProcessPageSearch $pps */
				$formatName = "page_$this->name";
				$pps = $this->wire('modules')->get('ProcessPageSearch');
				$pps->setDisplayFormat($formatName, $this->labelFieldFormat);
			}
			$labelFieldName = $this->labelFieldName == '.' ? 'name' : $this->labelFieldName;	
			$out .= "<input " . 
				"type='hidden' " . 
				"class='findPagesSelector' " . 
				"data-formatname='$formatName' " . 
				"data-label='$labelFieldName' " . 
				"value='$selector' />";
		}
		
		$out .= "\n</div>";

		return $out; 
	}

	protected function ___renderAddable() {

		if(!$this->addable || !$this->parent_id || !$this->template_id) return '';

		if($this->labelFieldName && $this->labelFieldName != 'title') return '';

		$parent = $this->wire('pages')->get($this->parent_id); 

		$test = new Page();
		$test->template = wire('templates')->get($this->template_id); 
		$test->parent = $parent; 
		$test->id = -1; // prevents permissions check from failing

		if(!$parent->addable($test)) return ''; 
		if(!$test->publishable()) return '';

		$inputfield = wire('modules')->get($this->inputfield); 
		if(!$inputfield) return '';
		$key = "_{$this->name}_add_items";

		if($inputfield instanceof InputfieldHasArrayValue) {
			// multi value
			$description = $this->_('Enter the titles of the items you want to add, one per line. They will be created and added to your selection when you save the page.');
			$input = "<textarea id='$key' name='$key' rows='5'></textarea>";
		} else {
			// single value
			$description = $this->_('Enter the title of the item you want to add. It will become selected when you save the page.');
			$input = "<input type='text' name='$key' id='$key' />";
		}

		$notes = sprintf($this->_('New pages will be added to %s'), $parent->path);
		$label ="<i class='fa fa-plus-circle'></i> " . $this->_('Create New'); 

		$out = 	"\n<div class='InputfieldPageAdd'>" . 	
			"\n\t<p class='InputfieldPageAddButton'><a href='#'>$label</a></p>" . 
			"\n\t<p class='InputfieldPageAddItems'>" . 
			"\n\t\t<label class='description' for='$key'>$description</label>" . 
			"\n\t\t$input" . 
			"\n\t\t<span class='detail'>$notes</span>" . 
			"\n\t</p>" . 
			"\n</div>";

		return $out; 
	}

	public function ___renderValue() {

		if($this->labelFieldName == '.') {
			$labelFieldFormat = $this->labelFieldFormat;
			$labelFieldName = 'title|name';
		} else {
			$labelFieldFormat = '';
			$labelFieldName = $this->labelFieldName ? $this->labelFieldName : 'title';
			$labelFieldName .= "|name";
		}
		
		$value = $this->attr('value');

		if(is_array($value) || $value instanceof PageArray) { 
			$out = '<ul class="PageArray">';
			foreach($value as $p) {
				$of = $p->of();
				$p->of(true);
				$v = $labelFieldFormat ? $p->getMarkup($labelFieldFormat) : $p->get($labelFieldName);
				if(!strlen($v)) $v = $p->get('name');
				$out .= "<li>$v</li>";
				$p->of($of);
			}
			$out .= "</ul>";

		} else if($value instanceof Page) {
			$of = $value->of();
			$value->of(true);
			$out = $labelFieldFormat ? $value->getMarkup($labelFieldFormat) : $value->get($labelFieldName);
			if(!strlen($out)) $out = $value->get('name');
			$value->of($of);

		} else {
			$out = $value; 
		}

		return $out; 
	}

	public function ___processInput(WireInputData $input) {

		$this->processInputMode = true; 
		$inputfield = $this->getInputfield();
		if(!$inputfield) return $this;
		$inputfield->processInput($input); 

		$value = $this->attr('value'); 
		$existingValueStr = $value ? "$value" : '';
		$newValue = null;
		$value = $inputfield->value;
		
		if(is_array($value)) {
			$newValue = new PageArray(); 
			foreach($value as $v) {
				$id = (int) $v; 
				if(!$id) continue; 
				if($id > 0) {	
					// existing page
					$page = $this->wire('pages')->get($id); 
					if($page->hasStatus(Page::statusUnpublished) && !$this->allowUnpub) continue; // disallow unpublished
				} else {
					// placeholder for new page, to be sorted later
					$page = new NullPage(); 
				}
				$newValue->add($page); 
			}

		} else if($value) {
			$newValue = $this->wire('pages')->get((int) $value); 
			if($newValue->hasStatus(Page::statusUnpublished) && !$this->allowUnpub) $newValue = null; // disallow unpublished
		}

		$this->setAttribute('value', $newValue); 
		$this->processInputAddPages($input);

		// if pages were added, re-sort them in case they were dragged to a different order
		// an example of this would be when used with the InputfieldPageAutocomplete
		if(count($this->pagesAdded) && is_array($value)) {
			$sortedValue = new PageArray();
			foreach($newValue as $page) {
				if($page->id < 1) $page = $this->pagesAdded->shift();
				if($page->id && !$sortedValue->has($page)) $sortedValue->add($page);
			}
			$newValue = $sortedValue;
			$this->setAttribute('value', $newValue); 
		}

		if("$newValue" != "$existingValueStr") {
			$this->trackChange('value'); 
		} 
		$this->processInputMode = false; 	
		return $this; 
	}

	/**
	 * Check for the addable pages option and process if applicable
	 * 
	 * @param WireInputData $input
	 *
	 */
	protected function ___processInputAddPages($input) {

		$this->pagesAdded = new PageArray();

		if(!$this->addable || !$this->parent_id || !$this->template_id) return;

		$user = wire('user'); 

		$key = "_{$this->name}_add_items";
		$value = trim($input->$key); 
		if(empty($value)) return;

		$parent = $this->pages->get($this->parent_id);
		$sort = $parent->numChildren;
		$titles = explode("\n", $value); 
		$publishable = false;
		$n = 0;

		foreach($titles as $title) {

			/**
			 * added by Can
			 */
			if (strpos($title, ':') !== false) {
				$titles = explode(':', $title);
				list($title, $title_de) = $titles;
				$german = $this->wire->languages->get('de');
			}

			// check if there is an existing page using this title
			$existingPage = $parent->child("include=all, templates_id={$this->template_id}, title=" . $this->sanitizer->selectorValue($title)); 
			if($existingPage->id) {
				// use existing page
				$this->pagesAdded->add($existingPage);
				if($this->value instanceof PageArray) {
					$this->value->add($existingPage); 
					continue; 
				} else {
					$this->value = $existingPage; 
					break;
				}
			}

			// create a new page
			$page = new Page();
			$page->template = $this->template_id; 
			$page->parent = $parent; 
			$page->title = trim($title);

			/**
			 * added by Can
			 */
			if (isset($title_de)) {
				$page->setLanguageValue($german, 'title', $title_de);
				$page->setLanguageValue($german, 'name', $title_de);
				$page->set("status$german->id", 1);
			}

			$page->sort = $sort++;
			$page->id = -1; // prevents the permissions check from failing

			// on first iteration perform a page-context access check
			if(!$n && (!$parent->addable($page) || !$page->publishable())) {
				$this->error("No access to add {$page->template} pages to {$parent->path}"); 
				break;
			}
			$page->id = 0;

			try {
				$page->save();
				$this->message(sprintf($this->_('Added page %s'), $page->path)); 
				if($this->value instanceof PageArray) $this->value->add($page); 
					else $this->value = $page; 
				$this->pagesAdded->add($page);
				$this->trackChange('value'); 
				$n++;

			} catch(Exception $e) {
				$error = sprintf($this->_('Error adding page "%s"'), $page->title);
				if($user->isSuperuser()) $error .= " - " . $e->getMessage(); 
				$this->error($error); 
				break;
			}

			if($this->value instanceof Page) break;
		}
	}

	public function isEmpty() {
		$value = $this->attr('value'); 

		if($value instanceof Page) {
			// derefAsPage
			return $value->id < 1; 

		} else if($value instanceof PageArray) {
			// derefAsPageArray
			if(!count($value)) return true; 

		} else {
			// null
			return true; 
		}

		return false; 
	}

	public function ___getConfigInputfields() {
		// let the module know it's being used for configuration purposes
		$this->configMode = true; 
		$exampleLabel = $this->_('Example:') . ' ';
		$defaultLabel = ' ' . $this->_('(default)'); 

		$inputfields = parent::___getConfigInputfields();

		$fieldset = wire('modules')->get('InputfieldFieldset'); 
		$fieldset->label = $this->_('Selectable Pages');
		$fieldset->attr('name', '_selectable_pages'); 

		$field = $this->modules->get('InputfieldPageListSelect');
		$field->setAttribute('name', 'parent_id'); 
		$field->label = $this->_('Parent of selectable page(s)');
		$field->attr('value', (int) $this->parent_id); 
		$field->description = $this->_('Select the parent of the pages that are selectable.');
		$field->required = false;
		$fieldset->append($field); 

		$field = $this->modules->get('InputfieldSelect');
		$field->setAttribute('name', 'template_id'); 
		$field->label = $this->_('Template of selectable page(s)');
		$field->attr('value', (int) $this->template_id); 
		$field->description = $this->_('Select the template of the pages that are selectable. May be used instead of, or in addition to, the parent above. NOTE: Not compatible with PageListSelect input field types.'); // Description for Template of selectable pages
		foreach($this->templates as $template) $field->addOption($template->id, $template->name); 
		$field->collapsed = Inputfield::collapsedBlank;
		$fieldset->append($field); 

		$field = $this->modules->get('InputfieldText'); 
		$field->attr('name', 'findPagesSelector'); 
		$field->label = $this->_('Custom selector to find selectable pages'); 
		$field->attr('value', $this->findPagesSelector); 
		$field->description = $this->_('If you want to find selectable pages using a ProcessWire selector rather than selecting a parent page or template (above) then enter the selector to find the selectable pages. This selector will be passed to a $pages->find("your selector"); statement. NOTE: Not currently compatible with PageListSelect input field types.'); // Description for Custom selector to find selectable pages
		$extra = $this->_('While this overrides parent and template selections above, those selections are still used for validation (de-select them if you do not want that behavior).'); // Additional notes
		$field->description .= ' ' . $extra;

		$field->notes = $exampleLabel . $this->_('parent=/products/, template=product, sort=name'); // Example of Custom selector to find selectable pages
		$field->collapsed = Inputfield::collapsedBlank;
		$fieldset->append($field); 

		$field = $this->modules->get('InputfieldTextarea'); 
		$field->attr('name', 'findPagesCode'); 
		$field->label = $this->_('Custom PHP code to find selectable pages'); 
		$field->attr('value', $this->findPagesCode); 
		$field->attr('rows', 4); 
		$field->description = $this->_('If you want to find selectable pages using a PHP code snippet rather than selecting a parent page or template (above) then enter the code to find the selectable pages. This statement has access to the $page and $pages API variables, where $page refers to the page being edited.'); // Description for Custom PHP to find selectable pages 1
		$field->description .= ' ' . $this->_('The snippet should return either a PageArray, Page or NULL. If it returns a Page, children of that Page are used as selectable pages. Using this is optional, and if used, it overrides the parent/template/selector fields above.'); // Description for Custom PHP to find selectable pages 2
		$field->description .= ' ' . $extra;
		$field->description .= ' ' . $this->_('NOTE: Not compatible with PageListSelect or Autocomplete input field types.'); // Description for Custom PHP to find selectable pages 3
		$field->notes = $exampleLabel . $this->_('return $page->parent->parent->children("name=locations")->first()->children();'); // Example of Custom PHP code to find selectable pages
		$field->collapsed = Inputfield::collapsedBlank;
		$fieldset->append($field); 

		$inputfields->append($fieldset); 

		$field = $this->modules->get('InputfieldSelect');
		$field->setAttribute('name', 'labelFieldName');
		$field->setAttribute('value', $this->labelFieldName); 
		$field->label = $this->_('Label field');
		$field->required = true; 
		$field->description = $this->_('Select the page field that you want to be used in generating the labels for each selectable page.'); // Description for Label Field
		$field->notes = $this->_('Select "Custom format" if you want to specify multiple fields, or other fields you do not see above.');
		$field->addOption('.', $this->_('Custom format (multiple fields)' . ' ...'));
		$field->columnWidth = 50;

		if($this->fuel('fields')->get('title')) {
			$field->addOption('title', 'title' . $defaultLabel);
			$field->addOption('name', 'name');
			$titleIsDefault = true;
		} else {
			$field->addOption('name', 'name' . $defaultLabel);
			$titleIsDefault = false;
		}
		$field->addOption('path', 'path'); 

		foreach($this->fuel('fields') as $f) {
			if(!$f->type instanceof FieldtypeText) continue;
			if($f->type instanceof FieldtypeTextarea) continue; 
			if($titleIsDefault && $f->name == 'title') continue;
			$field->addOption($f->name);
		}
		$inputfields->append($field); 
		
		$field = $this->modules->get('InputfieldText');
		$field->attr('name', 'labelFieldFormat');
		$field->attr('value', $this->labelFieldFormat);
		$field->label = $this->_('Custom page label format');
		$field->description = $this->_('Specify one or more field names surrounded by curly {brackets} along with any additional characters, spacing or punctuation.'); // Description for custom page label format
		$field->notes = $this->_('Example: {parent.title} - {title}, {date}'); 
		$field->columnWidth = 50;
		$field->showIf = 'labelFieldName=.';
		$field->required = true;
		$field->requiredIf = 'labelFieldName=.';
		$inputfields->add($field);

		if(!$this->inputfield) $this->inputfield = 'InputfieldSelect'; 
		$field = $this->modules->get('InputfieldSelect');
		$field->setAttribute('name', 'inputfield'); 
		$field->setAttribute('value', $this->inputfield); 
		$field->label = $this->_('Input field type');
		$field->description = $this->_('The type of field that will be used to select a page. Select one that is consistent with the single page vs. multi-page needs you chose in the "details" tab of this field.'); // Description for Inputfield field type
		$field->description .= ' ' . $this->_('Some input types may provide additional configuration options. After selecting an input field type, and then saving your changes, additional configuration options may appear below this section.'); // Description 2 for Inputfield field type
		$field->required = true; 
		$field->notes = '* ' . $this->_('Types indicated with an asterisk are for multiple page selection.') . "\n" . 
				'+ ' . $this->_('Types indicated with a plus assume a "parent" to be the root of a tree, rather than an immediate parent.'); 

		foreach($this->inputfieldClasses as $class) {
			$module = $this->modules->get($class); 
			$label = str_replace("Inputfield", '', $class);
			if($module instanceof InputfieldHasArrayValue) $label .= "*"; 
			if(is_subclass_of($module, 'InputfieldPageListSelection')) $label .= "+";
			$field->addOption($class, $label); 
		}

		$inputfields->append($field); 	

		$inputfield = $this->getInputfield();
		if($inputfield) {
			// then call again, knowing the module has it's config populated
			$inputfield->hasFieldtype = true; // tell it it's under control of a parent, regardless of whether this one is hasFieldtype true or not.
			foreach($inputfield->___getConfigInputfields() as $f) {
				if(in_array($f->name, array('required', 'collapsed', 'columnWidth')) || array_key_exists($f->name, self::$defaultConfig)) continue; 
				if($f->name && $inputfields->getChildByName($f->name)) continue; // if we already have the given field, skip over it to avoid duplication
				$inputfields->add($f); 
			}
		}

		if($this->hasFieldtype !== false) { 
			$field = $this->modules->get('InputfieldCheckbox');
			$field->attr('name', 'addable'); 
			$field->attr('value', 1); 
			$field->label = $this->_('Allow new pages to be created from field?');
			$field->description = $this->_('If checked, an option to add new page(s) will also be present if the indicated requirements are met.');
			$field->notes = 
				$this->_('1. Both a parent and template must be selected above.') . "\n" . 
				$this->_('2. The editing user must have access to create/publish these pages.') . "\n" . 
				$this->_('3. The label-field must be set to "title (default)".');

			if($this->addable) $field->attr('checked', 'checked'); 
				else $field->collapsed = Inputfield::collapsedYes;
			$inputfields->append($field); 
		}

		$this->configMode = false; // reverse what was set at the top of this function
		return $inputfields; 
	}

	static public function getModuleConfigInputfields(array $data) {

		$name = 'inputfieldClasses';

		if(!isset($data[$name]) || !is_array($data[$name])) $data[$name] = self::$defaultInputfieldClasses; 
		$fields = new InputfieldWrapper();
		$modules = Wire::getFuel('modules');
		$field = $modules->get("InputfieldAsmSelect");
		$field->attr('name', $name);
		foreach(Wire::getFuel('modules')->find('className^=Inputfield') as $inputfield) {
			$field->addOption($inputfield->className(), str_replace('Inputfield', '', $inputfield->className())); 
		}
		$field->attr('value', $data[$name]); 
		$field->label = __('Inputfield modules available for page selection', __FILE__);
		$field->description = __('Select the Inputfield modules that may be used for page selection. These should generally be Inputfields that allow you to select one or more options.', __FILE__); // Description 
		$fields->append($field);

		return $fields;
	}
	
}
 

I would love to read your thought on this.

Maybe it could be interesting to have it check for both (or all) languages if the provided exists, but I'm not exactly sure how to do that.

change user language via api and run line 610 again? Or a direct $database query would be possible.. By the way, I think it would be amazing to have language selectors, like a sub-selector "title.de" or something

[LostKobrakai]

Here's how you activate all languages for a page: https://processwire-recipes.com/recipes/activate-all-languages/

I like the idea for a language subselector, but there's always the chance of collision with other subfields as language names are arbitrary and there's no support for something like title.lang.de yet. 

[Can]

Thanks for sharing LostKobrakai,
I got only one additional language, so for me it fits for now, but with more it's better to automate it of cause.

That's a valid point I guess your idea title.lang.de is nice and then title.lang.all to query all languages