Movatterモバイル変換

98publicfunctiongetInputOOUI( $value ) {

99returnfalse;

100 }

113publicfunctiongetInputCodex( $value, $hasErrors ) {

115return $this->getInputHTML( $value );

116 }

124publicfunctioncanDisplayErrors() {

125return $this->hasVisibleOutput();

126 }

142publicfunctionmsg( $key, ...$params ) {

143if ( $this->mParent ) {

144return $this->mParent->msg( $key, ...$params );

145 }

146returnwfMessage( $key, ...$params );

147 }

156publicfunctionhasVisibleOutput() {

157returntrue;

158 }

166publicfunctiongetName() {

167return$this->mName;

168 }

181protectedfunctiongetNearestField( $name, $backCompat =false ) {

183 $cloner = $this->mParams['cloner'] ??null;

184if ( $cloner instanceofHTMLFormFieldCloner ) {

185 $field = $cloner->findNearestField( $this, $name );

186if ( $field ) {

187return $field;

188 }

189 }

191if ( $backCompat && str_starts_with( $name,'wp' ) &&

192 !$this->mParent->hasField( $name )

193 ) {

195return $this->mParent->getField( substr( $name, 2 ) );

196 }

197return $this->mParent->getField( $name );

198 }

211protectedfunctiongetNearestFieldValue( $alldata, $name, $asDisplay =false, $backCompat =false ) {

212 $field = $this->getNearestField( $name, $backCompat );

214 $cloner = $field->mParams['cloner'] ??null;

215if ( $cloner instanceofHTMLFormFieldCloner ) {

216 $value = $cloner->extractFieldData( $field, $alldata );

217 }else {

221 $value = $alldata[$field->mParams['fieldname']] ?? $field->getDefault();

222 }

225if ( $asDisplay && $field instanceofHTMLCheckField && ( $field->mParams['invert'] ??false ) ) {

226 $value = !$value;

227 }

229return $value;

230 }

242protectedfunctiongetNearestFieldByName( $alldata, $name, $asDisplay =false ) {

243return (string)$this->getNearestFieldValue( $alldata, $name, $asDisplay );

244 }

252protectedfunctionvalidateCondState( $params ) {

253 $origParams = $params;

254 $op = array_shift( $params );

256 $makeException =function (string $details ) use ( $origParams ): InvalidArgumentException {

257returnnew InvalidArgumentException(

258"Invalid hide-if or disable-if specification for $this->mName: " .

259 $details ." in " . var_export( $origParams,true )

260 );

261 };

263switch ( $op ) {

264case'NOT':

265if ( count( $params ) !== 1 ) {

266throw $makeException("NOT takes exactly one parameter" );

267 }

270case'AND':

271case'OR':

272case'NAND':

273case'NOR':

274foreach ( $params as $i => $p ) {

275if ( !is_array( $p ) ) {

276 $type = get_debug_type( $p );

277throw $makeException("Expected array, found $type at index $i" );

278 }

279 $this->validateCondState( $p );

280 }

281break;

283case'===':

284case'!==':

285case'CONTAINS':

286if ( count( $params ) !== 2 ) {

287throw $makeException("$op takes exactly two parameters" );

288 }

289 [ $name, $value ] = $params;

290if ( !is_string( $name ) || !is_string( $value ) ) {

291throw $makeException("Parameters for $op must be strings" );

292 }

293break;

295default:

296throw $makeException("Unknown operation" );

297 }

298 }

307protectedfunctioncheckStateRecurse( array $alldata, array $params ) {

308 $op = array_shift( $params );

309 $valueChk = ['AND' =>false,'OR' =>true,'NAND' =>false,'NOR' => true ];

310 $valueRet = ['AND' =>true,'OR' =>false,'NAND' =>false,'NOR' => true ];

312switch ( $op ) {

313case'AND':

314case'OR':

315case'NAND':

316case'NOR':

317foreach ( $params as $p ) {

318if ( $valueChk[$op] === $this->checkStateRecurse( $alldata, $p ) ) {

319return !$valueRet[$op];

320 }

321 }

322return $valueRet[$op];

324case'NOT':

325return !$this->checkStateRecurse( $alldata, $params[0] );

327case'===':

328case'!==':

329case'CONTAINS':

330 [ $field, $value ] = $params;

331 $testValue = $this->getNearestFieldValue( $alldata, $field,true,true );

332switch ( $op ) {

333case'===':

334return ( $value === (string)$testValue );

335case'!==':

336return ( $value !== (string)$testValue );

337case'CONTAINS':

338return in_array( $value, $testValue,true );

339 }

340 }

341 }

351protectedfunctionparseCondState( $params ) {

352 $op = array_shift( $params );

354switch ( $op ) {

355case'AND':

356case'OR':

357case'NAND':

358case'NOR':

359 $ret = [ $op ];

360foreach ( $params as $p ) {

361 $ret[] = $this->parseCondState( $p );

362 }

363return $ret;

365case'NOT':

366return ['NOT', $this->parseCondState( $params[0] ) ];

368case'===':

369case'!==':

370case'CONTAINS':

371 [ $name, $value ] = $params;

372 $field = $this->getNearestField( $name,true );

373return [ $op, $field->getName(), $value ];

374 }

375 }

382protectedfunctionparseCondStateForClient() {

383 $parsed = [];

384foreach ( $this->mCondState as $type => $params ) {

385 $parsed[$type] = $this->parseCondState( $params );

386 }

387return $parsed;

388 }

398publicfunctionisHidden( $alldata ) {

399return isset( $this->mCondState['hide'] ) &&

400 $this->checkStateRecurse( $alldata, $this->mCondState['hide'] );

401 }

411publicfunctionisDisabled( $alldata ) {

412return ( $this->mParams['disabled'] ??false ) ||

413 $this->isHidden( $alldata ) ||

414 ( isset( $this->mCondState['disable'] )

415 && $this->checkStateRecurse( $alldata, $this->mCondState['disable'] ) );

416 }

429publicfunctioncancelSubmit( $value, $alldata ) {

430returnfalse;

431 }

445publicfunctionvalidate( $value, $alldata ) {

446if ( $this->isHidden( $alldata ) ) {

447returntrue;

448 }

450if ( isset( $this->mParams['required'] )

451 && $this->mParams['required'] !==false

452 && ( $value ==='' || $value ===false || $value ===null )

453 ) {

454return $this->msg('htmlform-required' );

455 }

457if ( $this->mValidationCallback ===null ) {

458returntrue;

459 }

461 $p = ( $this->mValidationCallback )( $value, $alldata, $this->mParent );

463if ( $p instanceofStatusValue ) {

464 $language = $this->mParent ? $this->mParent->getLanguage() : RequestContext::getMain()->getLanguage();

466return $p->isGood() ? true : Status::wrap( $p )->getHTML(false,false, $language );

467 }

469return $p;

470 }

480publicfunctionfilter( $value, $alldata ) {

481if ( $this->mFilterCallback !==null ) {

482 $value = ( $this->mFilterCallback )( $value, $alldata, $this->mParent );

483 }

485return $value;

486 }

495protectedfunctionneedsLabel() {

496returntrue;

497 }

508publicfunctionsetShowEmptyLabel( $show ) {

509 $this->mShowEmptyLabels = $show;

510 }

523protectedfunctionisSubmitAttempt(WebRequest $request ) {

525return ( $request->wasPosted() && $request->getCheck('wpEditToken' ) )

527 || $request->getCheck('wpFormIdentifier' );

528 }

538publicfunctionloadDataFromRequest( $request ) {

539if ( $request->getCheck( $this->mName ) ) {

540return $request->getText( $this->mName );

541 }else {

542return $this->getDefault();

543 }

544 }

554publicfunction__construct( $params ) {

555 $this->mParams = $params;

557if ( isset( $params['parent'] ) && $params['parent'] instanceofHTMLForm ) {

558 $this->mParent = $params['parent'];

559 }else {

563wfDeprecatedMsg(

564 __METHOD__ .": Constructing an HTMLFormField without a 'parent' parameter",

566 );

567 }

570if ( isset( $params['label-message'] ) ) {

571 $this->mLabel = $this->getMessage( $params['label-message'] )->parse();

572 } elseif ( isset( $params['label'] ) ) {

573if ( $params['label'] ===' ' || $params['label'] ==="\u{00A0}" ) {

575 $this->mLabel ="\u{00A0}";

576 }else {

577 $this->mLabel = htmlspecialchars( $params['label'] );

578 }

579 } elseif ( isset( $params['label-raw'] ) ) {

580 $this->mLabel = $params['label-raw'];

581 }

583 $this->mName = $params['name'] ??'wp' . $params['fieldname'];

585if ( isset( $params['dir'] ) ) {

586 $this->mDir = $params['dir'];

587 }

589 $this->mID ="mw-input-{$this->mName}";

591if ( isset( $params['default'] ) ) {

592 $this->mDefault = $params['default'];

593 }

595if ( isset( $params['id'] ) ) {

596 $this->mID = $params['id'];

597 }

599if ( isset( $params['cssclass'] ) ) {

600 $this->mClass = $params['cssclass'];

601 }

603if ( isset( $params['csshelpclass'] ) ) {

604 $this->mHelpClass = $params['csshelpclass'];

605 }

607if ( isset( $params['validation-callback'] ) ) {

608 $this->mValidationCallback = $params['validation-callback'];

609 }

611if ( isset( $params['filter-callback'] ) ) {

612 $this->mFilterCallback = $params['filter-callback'];

613 }

615if ( isset( $params['hidelabel'] ) ) {

616 $this->mShowEmptyLabels =false;

617 }

618if ( isset( $params['notices'] ) ) {

619 $this->mNotices = $params['notices'];

620 }

622if ( isset( $params['hide-if'] ) && $params['hide-if'] ) {

623 $this->validateCondState( $params['hide-if'] );

624 $this->mCondState['hide'] = $params['hide-if'];

625 $this->mCondStateClass[] ='mw-htmlform-hide-if';

626 }

627if ( !( isset( $params['disabled'] ) && $params['disabled'] ) &&

628 isset( $params['disable-if'] ) && $params['disable-if']

629 ) {

630 $this->validateCondState( $params['disable-if'] );

631 $this->mCondState['disable'] = $params['disable-if'];

632 $this->mCondStateClass[] ='mw-htmlform-disable-if';

633 }

634 }

645publicfunctiongetTableRow( $value ) {

646 [ $errors, $errorClass ] = $this->getErrorsAndErrorClass( $value );

647 $inputHtml = $this->getInputHTML( $value );

648 $fieldType = $this->getClassName();

649 $helptext = $this->getHelpTextHtmlTable( $this->getHelpText() );

650 $cellAttributes = [];

651 $rowAttributes = [];

652 $rowClasses ='';

654if ( !empty( $this->mParams['vertical-label'] ) ) {

655 $cellAttributes['colspan'] = 2;

656 $verticalLabel =true;

657 }else {

658 $verticalLabel =false;

659 }

661 $label = $this->getLabelHtml( $cellAttributes );

663 $field = Html::rawElement(

664'td',

665 ['class' =>'mw-input' ] + $cellAttributes,

666 $inputHtml ."\n$errors"

667 );

669if ( $this->mCondState ) {

670 $rowAttributes['data-cond-state'] = FormatJson::encode( $this->parseCondStateForClient() );

671 $rowClasses .= implode(' ', $this->mCondStateClass );

672if ( $this->isHidden( $this->mParent->mFieldData ) ) {

673 $rowClasses .=' mw-htmlform-hide-if-hidden';

674 }

675 }

677if ( $verticalLabel ) {

678 $html = Html::rawElement('tr',

679 $rowAttributes + ['class' =>"mw-htmlform-vertical-label $rowClasses" ], $label );

680 $html .= Html::rawElement('tr',

681 $rowAttributes + [

682'class' =>"mw-htmlform-field-$fieldType {$this->mClass} $errorClass $rowClasses"

683 ],

684 $field );

685 }else {

686 $html = Html::rawElement('tr',

687 $rowAttributes + [

688'class' =>"mw-htmlform-field-$fieldType {$this->mClass} $errorClass $rowClasses"

689 ],

690 $label . $field );

691 }

693return $html . $helptext;

694 }

706publicfunctiongetDiv( $value ) {

707 [ $errors, $errorClass ] = $this->getErrorsAndErrorClass( $value );

708 $inputHtml = $this->getInputHTML( $value );

709 $fieldType = $this->getClassName();

710 $helptext = $this->getHelpTextHtmlDiv( $this->getHelpText() );

711 $cellAttributes = [];

712 $label = $this->getLabelHtml( $cellAttributes );

714 $outerDivClass = [

715'mw-input',

716'mw-htmlform-nolabel' => ( $label ==='' )

717 ];

719 $horizontalLabel = $this->mParams['horizontal-label'] ??false;

721if ( $horizontalLabel ) {

722 $field ="\u{00A0}" . $inputHtml ."\n$errors";

723 }else {

724 $field = Html::rawElement(

725'div',

727 ['class' => $outerDivClass ] + $cellAttributes,

728 $inputHtml ."\n$errors"

729 );

730 }

732 $wrapperAttributes = ['class' => [

733"mw-htmlform-field-$fieldType",

734$this->mClass,

735$this->mVFormClass,

736 $errorClass,

737 ] ];

738if ( $this->mCondState ) {

739 $wrapperAttributes['data-cond-state'] = FormatJson::encode( $this->parseCondStateForClient() );

740 $wrapperAttributes['class'] = array_merge( $wrapperAttributes['class'], $this->mCondStateClass );

741if ( $this->isHidden( $this->mParent->mFieldData ) ) {

742 $wrapperAttributes['class'][] ='mw-htmlform-hide-if-hidden';

743 }

744 }

745return Html::rawElement('div', $wrapperAttributes, $label . $field ) .

746 $helptext;

747 }

758publicfunctiongetOOUI( $value ) {

759 $inputField = $this->getInputOOUI( $value );

761if ( !$inputField ) {

765return $this->getFieldLayoutOOUI(

766new \OOUI\Widget( ['content' =>new \OOUI\HtmlSnippet( $this->getDiv( $value ) ) ] ),

767 ['align' =>'top' ]

768 );

769 }

771 $infusable =true;

772if ( is_string( $inputField ) ) {

776 $inputField = new \OOUI\Widget( ['content' =>new \OOUI\HtmlSnippet( $inputField ) ] );

777 $infusable =false;

778 }

780 $fieldType = $this->getClassName();

781 $help = $this->getHelpText();

782 $errors = $this->getErrorsRaw( $value );

783foreach ( $errors as &$error ) {

784 $error = new \OOUI\HtmlSnippet( $error );

785 }

787 $config = [

788'classes' => ["mw-htmlform-field-$fieldType" ],

789'align' => $this->getLabelAlignOOUI(),

790'help' => ( $help !==null && $help !=='' ) ?new \OOUI\HtmlSnippet( $help ) :null,

791'errors' => $errors,

792'infusable' => $infusable,

793'helpInline' => $this->isHelpInline(),

794'notices' => $this->mNotices ?: [],

795 ];

796if ( $this->mClass !=='' ) {

797 $config['classes'][] =$this->mClass;

798 }

800 $preloadModules =false;

802if ( $infusable && $this->shouldInfuseOOUI() ) {

803 $preloadModules =true;

804 $config['classes'][] ='mw-htmlform-autoinfuse';

805 }

806if ( $this->mCondState ) {

807 $config['classes'] = array_merge( $config['classes'], $this->mCondStateClass );

808if ( $this->isHidden( $this->mParent->mFieldData ) ) {

809 $config['classes'][] ='mw-htmlform-hide-if-hidden';

810 }

811 }

814 $label = $this->getLabel();

815if ( $label && $label !=="\u{00A0}" && $label !==' ' ) {

816 $config['label'] = new \OOUI\HtmlSnippet( $label );

817 }

819if ( $this->mCondState ) {

820 $preloadModules =true;

821 $config['condState'] = $this->parseCondStateForClient();

822 }

824 $config['modules'] = $this->getOOUIModules();

826if ( $preloadModules ) {

827 $this->mParent->getOutput()->addModules('mediawiki.htmlform.ooui' );

828 $this->mParent->getOutput()->addModules( $this->getOOUIModules() );

829 }

831return $this->getFieldLayoutOOUI( $inputField, $config );

832 }

841publicfunctiongetCodex( $value ) {

842 $isDisabled = ( $this->mParams['disabled'] ?? false );

845 $labelDiv ='';

846 $labelValue = trim( $this->getLabel() );

849if ( $labelValue !=='' && $labelValue !=="\u{00A0}" && $labelValue !==' ' ) {

850 $labelFor = $this->needsLabel() ? ['for' =>$this->mID ] : [];

851 $labelClasses = ['cdx-label' ];

852if ( $isDisabled ) {

853 $labelClasses[] ='cdx-label--disabled';

854 }

856 $labelDiv = Html::rawElement('div', ['class' => $labelClasses ],

858 Html::rawElement('label', ['class' =>'cdx-label__label' ] + $labelFor,

860 Html::rawElement('span', ['class' =>'cdx-label__label__text' ],

861 $labelValue

862 )

863 )

864 );

865 }

869 $helptext = $this->getHelpTextHtmlDiv( $this->getHelpText(), ['cdx-field__help-text' ] );

875 $validationMessage ='';

876 [ $errors, $errorClass ] = $this->getErrorsAndErrorClass( $value );

877if ( $errors !=='' ) {

878 $validationMessage = Html::rawElement('div', ['class' =>'cdx-field__validation-message' ],

879 $errors

880 );

881 }

884 $inputHtml = $this->getInputCodex( $value, $errors !=='' );

886 $controlClasses = ['cdx-field__control' ];

887if ( $helptext ) {

888 $controlClasses[] ='cdx-field__control--has-help-text';

889 }

890 $control = Html::rawElement('div', ['class' => $controlClasses ], $inputHtml );

893 $fieldClasses = [

894"mw-htmlform-field-{$this->getClassName()}",

895$this->mClass,

896 $errorClass,

898 ];

899if ( $isDisabled ) {

900 $fieldClasses[] ='cdx-field--disabled';

901 }

902 $fieldAttributes = [];

904if ( $this->mCondState ) {

905 $fieldAttributes['data-cond-state'] = FormatJson::encode( $this->parseCondStateForClient() );

906 $fieldClasses = array_merge( $fieldClasses, $this->mCondStateClass );

907if ( $this->isHidden( $this->mParent->mFieldData ) ) {

908 $fieldClasses[] ='mw-htmlform-hide-if-hidden';

909 }

910 }

912return Html::rawElement('div', ['class' => $fieldClasses ] + $fieldAttributes,

913 $labelDiv . $control . $helptext . $validationMessage

914 );

915 }

924protectedfunctiongetClassName() {

925 $name = explode('\\', static::class );

926return end( $name );

927 }

934protectedfunctiongetLabelAlignOOUI() {

935return'top';

936 }

944protectedfunctiongetFieldLayoutOOUI( $inputField, $config ) {

945returnnewHTMLFormFieldLayout( $inputField, $config );

946 }

956protectedfunctionshouldInfuseOOUI() {

958return !$this->isHelpInline() && $this->getHelpMessages();

959 }

968protectedfunctiongetOOUIModules() {

969return [];

970 }

982publicfunctiongetRaw( $value ) {

983 [ $errors, ] = $this->getErrorsAndErrorClass( $value );

984return"\n" . $errors .

985 $this->getLabelHtml() .

986 $this->getInputHTML( $value ) .

987 $this->getHelpTextHtmlRaw( $this->getHelpText() );

988 }

1000publicfunctiongetVForm( $value ) {

1001wfDeprecated( __METHOD__,'1.45' );

1003 $this->mVFormClass =' mw-ui-vform-field';

1004return $this->getDiv( $value );

1005 }

1014publicfunctiongetInline( $value ) {

1015 [ $errors, ] = $this->getErrorsAndErrorClass( $value );

1016return"\n" . $errors .

1017 $this->getLabelHtml() .

1018"\u{00A0}" .

1019 $this->getInputHTML( $value ) .

1020 $this->getHelpTextHtmlDiv( $this->getHelpText() );

1021 }

1030publicfunctiongetHelpTextHtmlTable( $helptext ) {

1031if ( $helptext ===null ) {

1032return'';

1033 }

1035 $rowAttributes = [];

1036if ( $this->mCondState ) {

1037 $rowAttributes['data-cond-state'] = FormatJson::encode( $this->parseCondStateForClient() );

1038 $rowAttributes['class'] =$this->mCondStateClass;

1039 }

1041 $tdClasses = ['htmlform-tip' ];

1042if ( $this->mHelpClass !==false ) {

1043 $tdClasses[] =$this->mHelpClass;

1044 }

1045return Html::rawElement('tr', $rowAttributes,

1046 Html::rawElement('td', ['colspan' => 2,'class' => $tdClasses ], $helptext )

1047 );

1048 }

1059publicfunctiongetHelpTextHtmlDiv( $helptext, $cssClasses = [] ) {

1060if ( $helptext ===null ) {

1061return'';

1062 }

1064 $wrapperAttributes = [

1065'class' => array_merge( $cssClasses, ['htmlform-tip' ] ),

1066 ];

1067if ( $this->mHelpClass !==false ) {

1068 $wrapperAttributes['class'][] =$this->mHelpClass;

1069 }

1070if ( $this->mCondState ) {

1071 $wrapperAttributes['data-cond-state'] = FormatJson::encode( $this->parseCondStateForClient() );

1072 $wrapperAttributes['class'] = array_merge( $wrapperAttributes['class'], $this->mCondStateClass );

1073 }

1074return Html::rawElement('div', $wrapperAttributes, $helptext );

1075 }

1084publicfunctiongetHelpTextHtmlRaw( $helptext ) {

1085return $this->getHelpTextHtmlDiv( $helptext );

1086 }

1109publicfunctiongetHelpText() {

1110 $html = [];

1112foreach ( $this->getHelpMessages() as $msg ) {

1113if ( $msg instanceofHtmlArmor ) {

1114 $html[] = HtmlArmor::getHtml( $msg );

1115 }else {

1116 $msg = $this->getMessage( $msg );

1117if ( $msg->exists() ) {

1118 $html[] = $msg->parse();

1119 }

1120 }

1121 }

1123return $html ? implode( $this->msg('word-separator' )->escaped(), $html ) :null;

1124 }

1134publicfunctionisHelpInline() {

1135return $this->mParams['help-inline'] ??true;

1136 }

1150publicfunctiongetErrorsAndErrorClass( $value ) {

1151 $errors = $this->validate( $value, $this->mParent->mFieldData );

1153if ( is_bool( $errors ) || !$this->mParent->wasSubmitted() ) {

1154return ['','' ];

1155 }

1157return [ self::formatErrors( $errors ),'mw-htmlform-invalid-input' ];

1158 }

1167publicfunctiongetErrorsRaw( $value ) {

1168 $errors = $this->validate( $value, $this->mParent->mFieldData );

1170if ( is_bool( $errors ) || !$this->mParent->wasSubmitted() ) {

1171return [];

1172 }

1174if ( !is_array( $errors ) ) {

1175 $errors = [ $errors ];

1176 }

1177foreach ( $errors as &$error ) {

1178if ( $error instanceofMessage ) {

1179 $error = $error->parse();

1180 }

1181 }

1183return $errors;

1184 }

1190publicfunctiongetLabel() {

1191return $this->mLabel ??'';

1192 }

1200publicfunctiongetLabelHtml( $cellAttributes = [] ) {

1203 $for = $this->needsLabel() ? ['for' => $this->mID ] : [];

1205 $labelValue = trim( $this->getLabel() );

1206 $hasLabel = $labelValue !=='' && $labelValue !=="\u{00A0}" && $labelValue !==' ';

1208 $displayFormat = $this->mParent->getDisplayFormat();

1209 $horizontalLabel = $this->mParams['horizontal-label'] ??false;

1211if ( $displayFormat ==='table' ) {

1212return Html::rawElement('td',

1213 ['class' =>'mw-label' ] + $cellAttributes,

1214 Html::rawElement('label', $for, $labelValue ) );

1215 } elseif ( $hasLabel || $this->mShowEmptyLabels ) {

1216if ( $displayFormat ==='div' && !$horizontalLabel ) {

1217return Html::rawElement('div',

1218 ['class' =>'mw-label' ] + $cellAttributes,

1219 Html::rawElement('label', $for, $labelValue ) );

1220 }else {

1221return Html::rawElement('label', $for, $labelValue );

1222 }

1223 }

1225return'';

1226 }

1232publicfunctiongetDefault() {

1233return $this->mDefault ??null;

1234 }

1241publicfunctiongetTooltipAndAccessKey() {

1242if ( empty( $this->mParams['tooltip'] ) ) {

1243return [];

1244 }

1246return Linker::tooltipAndAccesskeyAttribs( $this->mParams['tooltip'] );

1247 }

1254publicfunctiongetTooltipAndAccessKeyOOUI() {

1255if ( empty( $this->mParams['tooltip'] ) ) {

1256return [];

1257 }

1259return [

1260'title' => Linker::titleAttrib( $this->mParams['tooltip'] ),

1261'accessKey' => Linker::accesskey( $this->mParams['tooltip'] ),

1262 ];

1263 }

1272publicfunctiongetAttributes( array $list ) {

1273static $boolAttribs = ['disabled','required','autofocus','multiple','readonly' ];

1275 $ret = [];

1276foreach ( $list as $key ) {

1277if ( in_array( $key, $boolAttribs ) ) {

1278if ( !empty( $this->mParams[$key] ) ) {

1279 $ret[$key] ='';

1280 }

1281 } elseif ( isset( $this->mParams[$key] ) ) {

1282 $ret[$key] = $this->mParams[$key];

1283 }

1284 }

1286return $ret;

1287 }

1330publicstaticfunctionforceToStringRecursive( $array ) {

1331if ( is_array( $array ) ) {

1332return array_map( self::forceToStringRecursive( ... ), $array );

1333 }else {

1334return strval( $array );

1335 }

1336 }

1344publicfunctiongetOptions() {

1345if ( $this->mOptions ===false ) {

1346if ( array_key_exists('options-messages', $this->mParams ) ) {

1347 $needsParse = $this->mParams['options-messages-parse'] ??false;

1348if ( $needsParse ) {

1349 $this->mOptionsLabelsNotFromMessage =true;

1350 }

1351 $this->mOptions = $this->lookupOptionsKeys( $this->mParams['options-messages'], $needsParse );

1352 } elseif ( array_key_exists('options', $this->mParams ) ) {

1353 $this->mOptionsLabelsNotFromMessage =true;

1354 $this->mOptions = self::forceToStringRecursive( $this->mParams['options'] );

1355 } elseif ( array_key_exists('options-message', $this->mParams ) ) {

1356 $message = $this->getMessage( $this->mParams['options-message'] )->inContentLanguage()->plain();

1357 $this->mOptions = Html::listDropdownOptions( $message );

1358 }else {

1359 $this->mOptions =null;

1360 }

1361 }

1363return $this->mOptions;

1364 }

1371publicfunctiongetOptionsOOUI() {

1372 $oldoptions = $this->getOptions();

1374if ( $oldoptions ===null ) {

1375returnnull;

1376 }

1378return Html::listDropdownOptionsOoui( $oldoptions );

1379 }

1388publicstaticfunctionflattenOptions( $options ) {

1389 $flatOpts = [];

1391foreach ( $options as $value ) {

1392if ( is_array( $value ) ) {

1393 $flatOpts = array_merge( $flatOpts, self::flattenOptions( $value ) );

1394 }else {

1395 $flatOpts[] = $value;

1396 }

1397 }

1399return $flatOpts;

1400 }

1415protectedstaticfunctionformatErrors( $errors ) {

1416if ( is_array( $errors ) && count( $errors ) === 1 ) {

1417 $errors = array_shift( $errors );

1418 }

1420if ( is_array( $errors ) ) {

1421foreach ( $errors as &$error ) {

1422 $error = Html::rawElement('li', [],

1423 $error instanceofMessage ? $error->parse() : $error

1424 );

1425 }

1426 $errors = Html::rawElement('ul', [], implode("\n", $errors ) );

1427 } elseif ( $errors instanceofMessage ) {

1428 $errors = $errors->parse();

1429 }

1431return Html::errorBox( $errors );

1432 }

1440protectedfunctiongetMessage( $value ) {

1441 $message =Message::newFromSpecifier( $value );

1443if ( $this->mParent ) {

1444 $message->setContext( $this->mParent );

1445 }

1447return $message;

1448 }

1457publicfunctionskipLoadData( $request ) {

1458return !empty( $this->mParams['nodata'] );

1459 }

1468publicfunctionneedsJSForHtml5FormValidation() {

1470return (bool)$this->mCondState;

1471 }

1484protectedfunctionescapeLabel( $label ) {

1485return $this->mOptionsLabelsNotFromMessage

1486 ? $label : htmlspecialchars( $label, ENT_NOQUOTES );

1487 }

1500protectedfunctionmakeLabelSnippet( $label ) {

1501return $this->mOptionsLabelsNotFromMessage

1502 ? new \OOUI\HtmlSnippet( $label ) : $label;

1503 }