示例#1
0
 /**
  * Get inputfields for advanced settings of the Field and Fieldtype
  *
  * In most cases, you will want to override getConfigInputfields rather than this method
  *
  * @TODO should this be moved back into modules/Process/ProcessField.module? (that's where it is saved)
  *
  * @param Field $field
  * @return InputfieldWrapper
  *
  */
 public function ___getConfigAdvancedInputfields(Field $field)
 {
     // advanced settings
     $inputfields = new InputfieldWrapper();
     if ($this->getLoadQueryAutojoin($field, new DatabaseQuerySelect())) {
         $f = $this->modules->get('InputfieldCheckbox');
         $f->label = 'Autojoin';
         $f->attr('name', 'autojoin');
         $f->attr('value', 1);
         $f->attr('checked', $field->flags & Field::flagAutojoin ? 'checked' : '');
         $f->description = '' . "If checked, the data for this field will be loaded with every instance of the page, regardless of whether it's used at the time. " . "If unchecked, the data will be loaded on-demand, and only when the field is specifically accessed. " . "Enabling autojoin also allows the field to be used as a key for sorting pages.";
         $inputfields->append($f);
     }
     $f = $this->modules->get('InputfieldCheckbox');
     $f->attr('name', 'global');
     $f->label = 'Global';
     $f->description = "If checked, ALL pages will be required to have this field. " . "It will be automatically added to any fieldgroups/templates that don't already have it. " . "This does not mean that a value is required in the field, only that the editable field will exist in all pages.";
     $f->attr('value', 1);
     if ($field->flags & Field::flagGlobal) {
         $f->attr('checked', 'checked');
     } else {
         $f->collapsed = true;
     }
     $inputfields->append($f);
     if ($this->config->advanced) {
         $f = $this->modules->get('InputfieldCheckbox');
         $f->attr('name', 'system');
         $f->label = 'System';
         $f->description = "If checked, this field is considered a system field and is not renameable or deleteable. " . "System fields may not be undone using ProcessWire's API.";
         $f->attr('value', 1);
         if ($field->flags & Field::flagSystem) {
             $f->attr('checked', 'checked');
         } else {
             $f->collapsed = true;
         }
         $inputfields->append($f);
         $f = $this->modules->get('InputfieldCheckbox');
         $f->attr('name', 'permanent');
         $f->label = 'Permanent';
         $f->description = "If checked, this field is considered a permanent field and it can't be removed from any of the " . "system templates/fieldgroups to which it is attached. This flag may not be undone using ProcessWire's API.";
         $f->attr('value', 1);
         if ($field->flags & Field::flagPermanent) {
             $f->attr('checked', 'checked');
         } else {
             $f->collapsed = true;
         }
         $inputfields->append($f);
     }
     return $inputfields;
 }
示例#2
0
 /**
  * Get any custom configuration fields for this Inputfield
  *
  * Intended to be extended or overriden
  *
  * @return FormfieldWrapper
  *
  */
 public function ___getConfigInputfields()
 {
     $fields = new InputfieldWrapper();
     $field = $this->modules->get("InputfieldRadios");
     $field->attr('name', 'collapsed');
     $field->label = "How should this field be displayed in the editor?";
     $field->addOption(self::collapsedNo, "Always open");
     $field->addOption(self::collapsedBlank, "Collapsed only when blank");
     $field->addOption(self::collapsedYes, "Always collapsed, requiring a click to open");
     $field->addOption(self::collapsedHidden, "Hidden, not shown in the editor");
     $field->attr('value', (int) $this->collapsed);
     $fields->append($field);
     if ($this->config->advanced) {
         $field = $this->modules->get('InputfieldCheckbox');
         $field->label = 'Required?';
         $field->attr('name', 'required');
         $field->attr('value', 1);
         $field->attr('checked', $this->required ? 'checked' : '');
         $field->collapsed = self::collapsedBlank;
         $field->description = "If checked, a value will be required for this field.";
         $fields->append($field);
     }
     return $fields;
 }
示例#3
0
 /**
  * Get any configuration fields associated with the Inputfield
  *
  * @return InputfieldWrapper
  *
  */
 public function ___getConfigInputfields()
 {
     $wrapper = new InputfieldWrapper();
     $fieldgroupContext = $this->flags & Field::flagFieldgroupContext;
     if ($fieldgroupContext) {
         $allowContext = $this->type->getConfigAllowContext($this);
         if (!is_array($allowContext)) {
             $allowContext = array();
         }
     } else {
         $allowContext = array();
     }
     if (!$fieldgroupContext || count($allowContext)) {
         $inputfields = new InputfieldWrapper();
         if (!$fieldgroupContext) {
             $inputfields->head = $this->_('Field type details');
         }
         $inputfields->attr('title', $this->_('Details'));
         try {
             $fieldtypeInputfields = $this->type->getConfigInputfields($this);
             if (!$fieldtypeInputfields) {
                 $fieldtypeInputfields = new InputfieldWrapper();
             }
             $configArray = $this->type->getConfigArray($this);
             if (count($configArray)) {
                 $w = new InputfieldWrapper();
                 $w->importArray($configArray);
                 $w->populateValues($this);
                 $fieldtypeInputfields->import($w);
             }
             foreach ($fieldtypeInputfields as $inputfield) {
                 if ($fieldgroupContext && !in_array($inputfield->name, $allowContext)) {
                     continue;
                 }
                 $inputfields->append($inputfield);
             }
         } catch (Exception $e) {
             $this->trackException($e, false, true);
         }
         if (count($inputfields)) {
             $wrapper->append($inputfields);
         }
     }
     $inputfields = new InputfieldWrapper();
     $dummyPage = $this->wire('pages')->get("/");
     // only using this to satisfy param requirement
     if ($inputfield = $this->getInputfield($dummyPage)) {
         if ($fieldgroupContext) {
             $allowContext = array('visibility', 'collapsed', 'columnWidth', 'required', 'requiredIf', 'showIf');
             $allowContext = array_merge($allowContext, $inputfield->getConfigAllowContext($this));
         } else {
             $allowContext = array();
             $inputfields->head = $this->_('Input field settings');
         }
         $inputfields->attr('title', $this->_('Input'));
         $inputfieldInputfields = $inputfield->getConfigInputfields();
         if (!$inputfieldInputfields) {
             $inputfieldInputfields = new InputfieldWrapper();
         }
         $configArray = $inputfield->getConfigArray();
         if (count($configArray)) {
             $w = new InputfieldWrapper();
             $w->importArray($configArray);
             $w->populateValues($this);
             $inputfieldInputfields->import($w);
         }
         foreach ($inputfieldInputfields as $i) {
             if ($fieldgroupContext && !in_array($i->name, $allowContext)) {
                 continue;
             }
             $inputfields->append($i);
         }
     }
     $wrapper->append($inputfields);
     return $wrapper;
 }
示例#4
0
 /**
  * Get any custom configuration fields for this Inputfield
  *
  * Intended to be extended or overriden
  *
  * @return FormfieldWrapper
  *
  */
 public function ___getConfigInputfields()
 {
     $fields = new InputfieldWrapper();
     $field = $this->modules->get("InputfieldSelect");
     $field->attr('name', 'collapsed');
     $field->label = $this->_("Visibility");
     $field->description = $this->_("How should this field be displayed in the editor?");
     $field->addOption(self::collapsedNo, $this->_('Always open (default)'));
     $field->addOption(self::collapsedBlank, $this->_("Collapsed only when blank"));
     $field->addOption(self::collapsedPopulated, $this->_("Collapsed only when populated"));
     $field->addOption(self::collapsedYes, $this->_("Always collapsed, requiring a click to open"));
     $field->addOption(self::collapsedHidden, $this->_("Hidden, not shown in the editor"));
     $field->attr('value', (int) $this->collapsed);
     if ($this->collapsed == Inputfield::collapsedNo) {
         $field->collapsed = Inputfield::collapsedYes;
     }
     $fields->append($field);
     if (!$this instanceof InputfieldWrapper) {
         $field = $this->modules->get('InputfieldInteger');
         $value = (int) $this->getSetting('columnWidth');
         if ($value < 10 || $value >= 100) {
             $value = 100;
         }
         $field->label = sprintf($this->_("Column Width (%d%%)"), $value);
         $field->attr('id+name', 'columnWidth');
         $field->attr('maxlength', 4);
         $field->attr('size', 4);
         $field->attr('value', $value . '%');
         $field->description = $this->_("The percentage width of this field's container (10%-100%). If placed next to other fields with reduced widths, it will create floated columns.");
         // Description of colWidth option
         $field->notes = $this->_("Note that not all fields will work at reduced widths, so you should test the result after changing this.");
         // Notes for colWidth option
         if (!wire('input')->get('process_template')) {
             if ($value == 100) {
                 $field->collapsed = Inputfield::collapsedYes;
             }
         }
         $fields->append($field);
     }
     if ($this->config->advanced) {
         $field = $this->modules->get('InputfieldCheckbox');
         $field->label = $this->_('Required?');
         $field->attr('name', 'required');
         $field->attr('value', 1);
         $field->attr('checked', $this->required ? 'checked' : '');
         $field->collapsed = self::collapsedBlank;
         $field->description = $this->_("If checked, a value will be required for this field.");
         $fields->append($field);
     }
     return $fields;
 }
示例#5
0
 /**
  * Get any configuration fields associated with the Inputfield
  *
  * @return InputfieldWrapper
  *
  */
 public function ___getConfigInputfields()
 {
     $wrapper = new InputfieldWrapper();
     $fieldgroupContext = $this->flags & Field::flagFieldgroupContext;
     if (!$fieldgroupContext) {
         $inputfields = new InputfieldWrapper();
         $inputfields->head = $this->_('Field type details');
         $inputfields->attr('title', $this->_('Details'));
         try {
             $fieldtypeInputfields = $this->type->getConfigInputfields($this);
             if ($fieldtypeInputfields) {
                 foreach ($fieldtypeInputfields as $inputfield) {
                     $inputfields->append($inputfield);
                 }
             }
         } catch (Exception $e) {
             $this->error($e->getMessage());
         }
         if (count($inputfields)) {
             $wrapper->append($inputfields);
         }
     } else {
         // we currently exclude fieldtype configuration changes when in fieldgroup context
         // not sure that we need to, but keeping it simple to start
     }
     $inputfields = new InputfieldWrapper();
     $dummyPage = $this->fuel('pages')->get("/");
     // only using this to satisfy param requirement
     if ($inputfield = $this->getInputfield($dummyPage)) {
         if (!$fieldgroupContext) {
             $inputfields->head = $this->_('Input field settings');
         }
         $inputfields->attr('title', $this->_('Input'));
         $inputfieldInputfields = $inputfield->getConfigInputfields();
         if ($inputfieldInputfields) {
             foreach ($inputfieldInputfields as $i) {
                 // currently we only support collapsed and columnWidth for fieldgroup context
                 // however we may support everything after starting with these limited options for awhile
                 if ($fieldgroupContext && !in_array($i->name, array('visibility', 'collapsed', 'columnWidth', 'required', 'requiredIf', 'showIf'))) {
                     continue;
                 }
                 $inputfields->append($i);
             }
         }
     }
     $wrapper->append($inputfields);
     return $wrapper;
 }
 /**
  * Get any custom configuration fields for this Inputfield
  *
  * Intended to be extended by each Inputfield as needed to add more config options. 
  * 
  * NOTE: Inputfields with a name that starts with an underscore, i.e. "_myname" are assumed to be for runtime
  * use and are NOT stored in the database.
  *
  * @return InputfieldWrapper
  *
  */
 public function ___getConfigInputfields()
 {
     $conditionsText = $this->_('Conditions are expressed with a "field=value" selector containing fields and values to match. Multiple conditions should be separated by a comma.');
     $conditionsNote = $this->_('Read more about [how to use this](http://processwire.com/api/selectors/inputfield-dependencies/).');
     $fields = new InputfieldWrapper();
     $fieldset = $this->modules->get('InputfieldFieldset');
     $fieldset->label = $this->_('Visibility');
     $fieldset->attr('name', 'visibility');
     $fieldset->icon = 'eye';
     $field = $this->modules->get("InputfieldSelect");
     $field->attr('name', 'collapsed');
     $field->label = $this->_('Presentation');
     $field->description = $this->_("How should this field be displayed in the editor?");
     $field->addOption(self::collapsedNo, $this->_('Always open (default)'));
     $field->addOption(self::collapsedNever, $this->_('Always open and cannot be collapsed'));
     $field->addOption(self::collapsedBlank, $this->_("Collapsed only when blank"));
     $field->addOption(self::collapsedPopulated, $this->_("Collapsed only when populated"));
     $field->addOption(self::collapsedYes, $this->_("Always collapsed, requiring a click to open"));
     $field->addOption(self::collapsedHidden, $this->_("Hidden, not shown in the editor"));
     $field->addOption(self::collapsedYesLocked, $this->_("Always collapsed and not editable (locked)"));
     $field->addOption(self::collapsedNoLocked, $this->_("Open when populated and not editable (locked)"));
     $field->attr('value', (int) $this->collapsed);
     $fieldset->append($field);
     $field = $this->modules->get("InputfieldText");
     $field->label = $this->_('Show this field only if...');
     $field->description = $this->_('Enter the conditions under which the field will be shown.') . ' ' . $conditionsText;
     $field->notes = $conditionsNote;
     $field->icon = 'question-circle';
     $field->attr('name', 'showIf');
     $field->attr('value', $this->getSetting('showIf'));
     $field->collapsed = Inputfield::collapsedBlank;
     $field->showIf = "collapsed!=" . self::collapsedHidden;
     $fieldset->append($field);
     $fieldset->collapsed = $this->collapsed == Inputfield::collapsedNo && !$this->getSetting('showIf') ? Inputfield::collapsedYes : Inputfield::collapsedNo;
     $fields->append($fieldset);
     $field = $this->modules->get('InputfieldInteger');
     $value = (int) $this->getSetting('columnWidth');
     if ($value < 10 || $value >= 100) {
         $value = 100;
     }
     $field->label = sprintf($this->_("Column Width (%d%%)"), $value);
     $field->icon = 'arrows-h';
     $field->attr('id+name', 'columnWidth');
     $field->attr('type', 'text');
     $field->attr('maxlength', 4);
     $field->attr('size', 4);
     $field->attr('max', 100);
     $field->attr('value', $value . '%');
     $field->description = $this->_("The percentage width of this field's container (10%-100%). If placed next to other fields with reduced widths, it will create floated columns.");
     // Description of colWidth option
     $field->notes = $this->_("Note that not all fields will work at reduced widths, so you should test the result after changing this.");
     // Notes for colWidth option
     if (!wire('input')->get('process_template')) {
         if ($value == 100) {
             $field->collapsed = Inputfield::collapsedYes;
         }
     }
     $fields->append($field);
     if (!$this instanceof InputfieldWrapper) {
         $field = $this->modules->get('InputfieldCheckbox');
         $field->label = $this->_('Required?');
         $field->icon = 'asterisk';
         $field->attr('name', 'required');
         $field->attr('value', 1);
         $field->attr('checked', $this->getSetting('required') ? 'checked' : '');
         $field->description = $this->_("If checked, a value will be required for this field.");
         $field->collapsed = $this->getSetting('required') ? Inputfield::collapsedNo : Inputfield::collapsedYes;
         $fields->add($field);
         $field = $this->modules->get('InputfieldText');
         $field->label = $this->_('Required only if...');
         $field->icon = 'asterisk';
         $field->description = $this->_('Enter the conditions under which a value will be required for this field.') . ' ' . $conditionsText;
         $field->notes = $conditionsNote;
         $field->attr('name', 'requiredIf');
         $field->attr('value', $this->getSetting('requiredIf'));
         $field->collapsed = $field->attr('value') ? Inputfield::collapsedNo : Inputfield::collapsedYes;
         $field->showIf = "required>0";
         $fields->add($field);
     }
     return $fields;
 }
示例#7
0
 /**
  * Get the Inputfields that configure the given module or return null if not configurable
  * 
  * @param string|Module|int $moduleName
  * @param InputfieldWrapper|null $form Optionally specify the form you want Inputfields appended to.
  * @return InputfieldWrapper|null
  * 
  */
 public function ___getModuleConfigInputfields($moduleName, InputfieldWrapper $form = null)
 {
     $moduleName = $this->getModuleClass($moduleName);
     $configurable = $this->isConfigurableModule($moduleName);
     if (!$configurable) {
         return null;
     }
     if (is_null($form)) {
         $form = new InputfieldWrapper();
     }
     $data = $this->modules->getModuleConfigData($moduleName);
     // check for configurable module interface
     $configurableInterface = $this->isConfigurableModule($moduleName, "interface");
     if ($configurableInterface) {
         if (is_int($configurableInterface) && $configurableInterface > 1 && $configurableInterface < 20) {
             // non-static
             /** @var ConfigurableModule $module */
             $module = $this->getModule($moduleName);
             if ($configurableInterface === 2) {
                 // requires no arguments
                 $fields = $module->getModuleConfigInputfields();
             } else {
                 if ($configurableInterface === 3) {
                     // requires $data array
                     $fields = $module->getModuleConfigInputfields($data);
                 } else {
                     if ($configurableInterface === 4) {
                         // requires InputfieldWrapper
                         // we allow for option of no return statement in the method
                         $fields = new InputfieldWrapper();
                         $_fields = $module->getModuleConfigInputfields($fields);
                         if ($_fields instanceof InputfieldWrapper) {
                             $fields = $_fields;
                         }
                         unset($_fields);
                     } else {
                         if ($configurableInterface === 19) {
                             // non-static getModuleConfigArray method
                             $fields = new InputfieldWrapper();
                             $fields->importArray($module->getModuleConfigArray());
                             $fields->populateValues($module);
                         }
                     }
                 }
             }
         } else {
             if ($configurableInterface === 20) {
                 // static getModuleConfigArray method
                 $fields = new InputfieldWrapper();
                 $fields->importArray(call_user_func(array($moduleName, 'getModuleConfigArray')));
                 $fields->populateValues($data);
             } else {
                 if ($configurableInterface) {
                     // static getModuleConfigInputfields method
                     $fields = call_user_func(array($moduleName, 'getModuleConfigInputfields'), $data);
                 }
             }
         }
         if ($fields instanceof InputfieldWrapper) {
             foreach ($fields as $field) {
                 $form->append($field);
             }
         } else {
             if ($fields instanceof Inputfield) {
                 $form->append($fields);
             } else {
                 $this->error("{$moduleName}.getModuleConfigInputfields() did not return InputfieldWrapper");
             }
         }
     }
     // check for file-based config
     $file = $this->isConfigurableModule($moduleName, "file");
     if (!$file || !is_string($file) || !is_file($file)) {
         return $form;
     }
     $config = null;
     include_once $file;
     $configClass = $moduleName . "Config";
     $configModule = null;
     if (class_exists($configClass)) {
         // file contains a ModuleNameConfig class
         $configModule = new $configClass();
     } else {
         if (is_null($config)) {
             include $file;
         }
         // in case of previous include_once
         if (is_array($config)) {
             // file contains a $config array
             $configModule = new ModuleConfig();
             $configModule->add($config);
         }
     }
     if ($configModule && $configModule instanceof ModuleConfig) {
         $defaults = $configModule->getDefaults();
         $data = array_merge($defaults, $data);
         $configModule->setArray($data);
         $fields = $configModule->getInputfields();
         if ($fields instanceof InputfieldWrapper) {
             foreach ($fields as $field) {
                 $form->append($field);
             }
             foreach ($data as $key => $value) {
                 $f = $form->getChildByName($key);
                 if ($f) {
                     $f->attr('value', $value);
                 }
             }
         } else {
             $this->error("{$configModule}.getInputfields() did not return InputfieldWrapper");
         }
     }
     return $form;
 }
 /**
  * Get any configuration fields associated with the Inputfield
  *
  * @return InputfieldWrapper
  *
  */
 public function ___getConfigInputfields()
 {
     $wrapper = new InputfieldWrapper();
     $inputfields = $this->modules->get("InputfieldFieldset");
     $inputfields->description = "The following settings are requested by {$this->type->name}";
     $inputfields->label = "Fieldtype Settings";
     $fieldtypeInputfields = $this->type->getConfigInputfields($this);
     if ($fieldtypeInputfields) {
         foreach ($fieldtypeInputfields as $inputfield) {
             $inputfields->append($inputfield);
         }
     }
     if (count($inputfields)) {
         $wrapper->append($inputfields);
     }
     $inputfields = $this->modules->get("InputfieldFieldset");
     $dummyPage = $this->fuel('pages')->get("/");
     // only using this to satisfy param requirement
     if ($inputfield = $this->getInputfield($dummyPage)) {
         $inputfieldLabel = $inputfield->className();
         $inputfields->description = "The following settings are requested by {$inputfieldLabel}, which accompanies {$this->type->name}";
         $inputfields->label = "Inputfield Settings";
         $inputfieldInputfields = $inputfield->getConfigInputfields();
         if ($inputfieldInputfields) {
             foreach ($inputfieldInputfields as $i) {
                 $inputfields->append($i);
             }
         }
     }
     $wrapper->append($inputfields);
     return $wrapper;
 }
示例#9
0
 /**
  * Get any configuration Inputfields common to all InputfieldWrappers
  *
  */
 public function ___getConfigInputfields()
 {
     $fields = new InputfieldWrapper();
     $field = $this->modules->get("InputfieldRadios");
     $field->attr('name', 'collapsed');
     $field->label = $this->_("How should this field be displayed?");
     $field->addOption(Inputfield::collapsedNo, $this->_("Always open"));
     $field->addOption(Inputfield::collapsedYes, $this->_("Always collapsed, requiring a click to open"));
     $field->attr('value', (int) $this->collapsed);
     $fields->append($field);
     return $fields;
 }
示例#10
0
文件: Field.php 项目: nicolasleon/P21
 /**
  * Get any configuration fields associated with the Inputfield
  *
  * @return InputfieldWrapper
  *
  */
 public function ___getConfigInputfields()
 {
     $wrapper = new InputfieldWrapper();
     $inputfields = new InputfieldWrapper();
     $inputfields->head = "Field type details";
     $inputfields->attr('title', 'Details');
     $fieldtypeInputfields = $this->type->getConfigInputfields($this);
     if ($fieldtypeInputfields) {
         foreach ($fieldtypeInputfields as $inputfield) {
             $inputfields->append($inputfield);
         }
     }
     if (count($inputfields)) {
         $wrapper->append($inputfields);
     }
     $inputfields = new InputfieldWrapper();
     $dummyPage = $this->fuel('pages')->get("/");
     // only using this to satisfy param requirement
     if ($inputfield = $this->getInputfield($dummyPage)) {
         $inputfieldLabel = $inputfield->className();
         $inputfields->head = "Input field settings";
         $inputfields->attr('title', 'Input');
         $inputfieldInputfields = $inputfield->getConfigInputfields();
         if ($inputfieldInputfields) {
             foreach ($inputfieldInputfields as $i) {
                 $inputfields->append($i);
             }
         }
     }
     $wrapper->append($inputfields);
     return $wrapper;
 }