TablePager.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Pager;
 
use MediaWiki\Context\IContextSource;
use MediaWiki\Html\Html;
use MediaWiki\Linker\LinkRenderer;
use MediaWiki\Parser\ParserOutput;
use MediaWiki\Xml\XmlSelect;
use OOUI\ButtonGroupWidget;
use OOUI\ButtonWidget;
use stdClass;
 
abstract class TablePager extends IndexPager {
    protected $mSort;
 
    protected $mCurrentRow;
 
    public function __construct( ?IContextSource $context = null, ?LinkRenderer $linkRenderer = null ) {
        if ( $context ) {
            $this->setContext( $context );
        }
 
        $this->mSort = $this->getRequest()->getText( 'sort' );
        if ( !array_key_exists( $this->mSort, $this->getFieldNames() )
            || !$this->isFieldSortable( $this->mSort )
        ) {
            $this->mSort = $this->getDefaultSort();
        }
        if ( $this->getRequest()->getBool( 'asc' ) ) {
            $this->mDefaultDirection = IndexPager::DIR_ASCENDING;
        } elseif ( $this->getRequest()->getBool( 'desc' ) ) {
            $this->mDefaultDirection = IndexPager::DIR_DESCENDING;
        } /* Else leave it at whatever the class default is */
 
        // Parent constructor needs mSort set, so we call it last
        parent::__construct( null, $linkRenderer );
    }
 
    public function getBodyOutput() {
        $body = parent::getBody();
 
        $pout = new ParserOutput;
        $pout->setRawText( $body );
        return $pout;
    }
 
    public function getFullOutput() {
        $navigation = $this->getNavigationBar();
        $body = parent::getBody();
 
        $pout = new ParserOutput;
        $pout->setRawText( $navigation . $body . $navigation );
        $pout->addModuleStyles( $this->getModuleStyles() );
        return $pout;
    }
 
    protected function getStartBody() {
        $sortClass = $this->getSortHeaderClass();
 
        $s = '';
        $fields = $this->getFieldNames();
 
        // Make table header
        foreach ( $fields as $field => $name ) {
            if ( strval( $name ) == '' ) {
                $s .= Html::rawElement( 'th', [], "\u{00A0}" ) . "\n";
            } elseif ( $this->isFieldSortable( $field ) ) {
                $query = [ 'sort' => $field, 'limit' => $this->mLimit ];
                $linkType = null;
                $class = null;
 
                if ( $this->mSort == $field ) {
                    // The table is sorted by this field already, make a link to sort in the other direction
                    // We don't actually know in which direction other fields will be sorted by default…
                    if ( $this->mDefaultDirection == IndexPager::DIR_DESCENDING ) {
                        $linkType = 'asc';
                        $class = "$sortClass mw-datatable-is-sorted mw-datatable-is-descending";
                        $query['asc'] = '1';
                        $query['desc'] = '';
                    } else {
                        $linkType = 'desc';
                        $class = "$sortClass mw-datatable-is-sorted mw-datatable-is-ascending";
                        $query['asc'] = '';
                        $query['desc'] = '1';
                    }
                }
 
                $link = $this->makeLink( htmlspecialchars( $name ), $query, $linkType );
                $s .= Html::rawElement( 'th', [ 'class' => $class ], $link ) . "\n";
            } else {
                $s .= Html::element( 'th', [], $name ) . "\n";
            }
        }
 
        $ret = Html::openElement( 'table', [
            'class' => $this->getTableClass() ]
        );
        $ret .= Html::rawElement( 'thead', [], Html::rawElement( 'tr', [], "\n" . $s . "\n" ) );
        $ret .= Html::openElement( 'tbody' ) . "\n";
 
        return $ret;
    }
 
    protected function getEndBody() {
        return "</tbody></table>\n";
    }
 
    protected function getEmptyBody() {
        $colspan = count( $this->getFieldNames() );
        $msgEmpty = $this->msg( 'table_pager_empty' )->text();
        return Html::rawElement( 'tr', [],
            Html::element( 'td', [ 'colspan' => $colspan ], $msgEmpty ) );
    }
 
    public function formatRow( $row ) {
        $this->mCurrentRow = $row; // In case formatValue etc need to know
        $s = Html::openElement( 'tr', $this->getRowAttrs( $row ) ) . "\n";
        $fieldNames = $this->getFieldNames();
 
        foreach ( $fieldNames as $field => $name ) {
            $value = $row->$field ?? null;
            $formatted = strval( $this->formatValue( $field, $value ) );
 
            if ( $formatted == '' ) {
                $formatted = "\u{00A0}";
            }
 
            $s .= Html::rawElement( 'td', $this->getCellAttrs( $field, $value ), $formatted ) . "\n";
        }
 
        $s .= Html::closeElement( 'tr' ) . "\n";
 
        return $s;
    }
 
    protected function getRowClass( $row ) {
        return '';
    }
 
    protected function getRowAttrs( $row ) {
        return [ 'class' => $this->getRowClass( $row ) ];
    }
 
    protected function getCurrentRow() {
        return $this->mCurrentRow;
    }
 
    protected function getCellAttrs( $field, $value ) {
        return [ 'class' => 'TablePager_col_' . $field ];
    }
 
    public function getIndexField() {
        return $this->mSort;
    }
 
    protected function getTableClass() {
        return 'mw-datatable';
    }
 
    protected function getNavClass() {
        return 'TablePager_nav';
    }
 
    protected function getSortHeaderClass() {
        return 'TablePager_sort';
    }
 
    public function getNavigationBar() {
        if ( !$this->isNavigationBarShown() ) {
            return '';
        }
 
        $this->getOutput()->enableOOUI();
 
        $types = [ 'first', 'prev', 'next', 'last' ];
 
        $queries = $this->getPagingQueries();
 
        $buttons = [];
 
        $title = $this->getTitle();
 
        foreach ( $types as $type ) {
            $buttons[] = new ButtonWidget( [
                // Messages used here:
                // * table_pager_first
                // * table_pager_prev
                // * table_pager_next
                // * table_pager_last
                'classes' => [ 'TablePager-button-' . $type ],
                'flags' => [ 'progressive' ],
                'framed' => false,
                'label' => $this->msg( 'table_pager_' . $type )->text(),
                'href' => $queries[ $type ] ?
                    $title->getLinkURL( $queries[ $type ] + $this->getDefaultQuery() ) :
                    null,
                'icon' => $type === 'prev' ? 'previous' : $type,
                'disabled' => $queries[ $type ] === false
            ] );
        }
        return ( new ButtonGroupWidget( [
            'classes' => [ $this->getNavClass() ],
            'items' => $buttons,
        ] ) )->toString();
    }
 
    public function getModuleStyles() {
        return array_merge(
            parent::getModuleStyles(), [ 'oojs-ui.styles.icons-movement' ]
        );
    }
 
    public function getLimitSelect( array $attribs = [] ): string {
        $select = new XmlSelect( 'limit', false, $this->mLimit );
        $select->addOptions( $this->getLimitSelectList() );
        foreach ( $attribs as $name => $value ) {
            $select->setAttribute( $name, $value );
        }
        return $select->getHTML();
    }
 
    public function getLimitSelectList() {
        # Add the current limit from the query string
        # to avoid that the limit is lost after clicking Go next time
        if ( !in_array( $this->mLimit, $this->mLimitsShown ) ) {
            $this->mLimitsShown[] = $this->mLimit;
            sort( $this->mLimitsShown );
        }
        $ret = [];
        foreach ( $this->mLimitsShown as $key => $value ) {
            # The pair is either $index => $limit, in which case the $value
            # will be numeric, or $limit => $text, in which case the $value
            # will be a string.
            if ( is_int( $value ) ) {
                $limit = $value;
                $text = $this->getLanguage()->formatNum( $limit );
            } else {
                $limit = $key;
                $text = $value;
            }
            $ret[$text] = $limit;
        }
        return $ret;
    }
 
    public function getHiddenFields( $noResubmit = [] ) {
        $noResubmit = (array)$noResubmit;
        $query = $this->getRequest()->getQueryValues();
        foreach ( $noResubmit as $name ) {
            unset( $query[$name] );
        }
        $s = '';
        foreach ( $query as $name => $value ) {
            if ( is_array( $value ) ) {
                // Per WebRequest::getVal: Array values are discarded for security reasons.
                continue;
            }
            $s .= Html::hidden( $name, $value ) . "\n";
        }
        return $s;
    }
 
    public function getLimitForm() {
        return Html::rawElement(
            'form',
            [
                'method' => 'get',
                'action' => wfScript(),
            ],
            "\n" . $this->getLimitDropdown()
        ) . "\n";
    }
 
    private function getLimitDropdown() {
        # Make the select with some explanatory text
        $msgSubmit = $this->msg( 'table_pager_limit_submit' )->escaped();
 
        return $this->msg( 'table_pager_limit' )
            ->rawParams( $this->getLimitSelect() )->escaped() .
            "\n<input type=\"submit\" value=\"$msgSubmit\"/>\n" .
            $this->getHiddenFields( [ 'limit' ] );
    }
 
    abstract protected function isFieldSortable( $field );
 
    abstract public function formatValue( $name, $value );
 
    abstract public function getDefaultSort();
 
    abstract protected function getFieldNames();
}
 
class_alias( TablePager::class, 'TablePager' );