Pager.php

Go to the documentation of this file.

<?php
interface Pager {
    function getNavigationBar();
    function getBody();
}
 
abstract class IndexPager extends ContextSource implements Pager {
    public $mRequest;
    public $mLimitsShown = array( 20, 50, 100, 250, 500 );
    public $mDefaultLimit = 50;
    public $mOffset, $mLimit;
    public $mQueryDone = false;
    public $mDb;
    public $mPastTheEndRow;
 
    protected $mIndexField;
    protected $mExtraSortFields;
    protected $mOrderType;
    public $mDefaultDirection;
    public $mIsBackwards;
 
    public $mIsFirst;
    public $mIsLast;
 
    protected $mLastShown, $mFirstShown, $mPastTheEndIndex, $mDefaultQuery, $mNavigationBar;
 
    protected $mIncludeOffset = false;
 
    public $mResult;
 
    public function __construct( IContextSource $context = null ) {
        if ( $context ) {
            $this->setContext( $context );
        }
 
        $this->mRequest = $this->getRequest();
 
        # NB: the offset is quoted, not validated. It is treated as an
        # arbitrary string to support the widest variety of index types. Be
        # careful outputting it into HTML!
        $this->mOffset = $this->mRequest->getText( 'offset' );
 
        # Use consistent behavior for the limit options
        $this->mDefaultLimit = $this->getUser()->getIntOption( 'rclimit' );
        if ( !$this->mLimit ) {
            // Don't override if a subclass calls $this->setLimit() in its constructor.
            list( $this->mLimit, /* $offset */ ) = $this->mRequest->getLimitOffset();
        }
 
        $this->mIsBackwards = ( $this->mRequest->getVal( 'dir' ) == 'prev' );
        # Let the subclass set the DB here; otherwise use a slave DB for the current wiki
        $this->mDb = $this->mDb ?: wfGetDB( DB_SLAVE );
 
        $index = $this->getIndexField(); // column to sort on
        $extraSort = $this->getExtraSortFields(); // extra columns to sort on for query planning
        $order = $this->mRequest->getVal( 'order' );
        if ( is_array( $index ) && isset( $index[$order] ) ) {
            $this->mOrderType = $order;
            $this->mIndexField = $index[$order];
            $this->mExtraSortFields = isset( $extraSort[$order] )
                ? (array)$extraSort[$order]
                : array();
        } elseif ( is_array( $index ) ) {
            # First element is the default
            reset( $index );
            list( $this->mOrderType, $this->mIndexField ) = each( $index );
            $this->mExtraSortFields = isset( $extraSort[$this->mOrderType] )
                ? (array)$extraSort[$this->mOrderType]
                : array();
        } else {
            # $index is not an array
            $this->mOrderType = null;
            $this->mIndexField = $index;
            $this->mExtraSortFields = (array)$extraSort;
        }
 
        if ( !isset( $this->mDefaultDirection ) ) {
            $dir = $this->getDefaultDirections();
            $this->mDefaultDirection = is_array( $dir )
                ? $dir[$this->mOrderType]
                : $dir;
        }
    }
 
    public function getDatabase() {
        return $this->mDb;
    }
 
    public function doQuery() {
        # Use the child class name for profiling
        $fname = __METHOD__ . ' (' . get_class( $this ) . ')';
        wfProfileIn( $fname );
 
        $descending = ( $this->mIsBackwards == $this->mDefaultDirection );
        # Plus an extra row so that we can tell the "next" link should be shown
        $queryLimit = $this->mLimit + 1;
 
        if ( $this->mOffset == '' ) {
            $isFirst = true;
        } else {
            // If there's an offset, we may or may not be at the first entry.
            // The only way to tell is to run the query in the opposite
            // direction see if we get a row.
            $oldIncludeOffset = $this->mIncludeOffset;
            $this->mIncludeOffset = !$this->mIncludeOffset;
            $isFirst = !$this->reallyDoQuery( $this->mOffset, 1, !$descending )->numRows();
            $this->mIncludeOffset = $oldIncludeOffset;
        }
 
        $this->mResult = $this->reallyDoQuery(
            $this->mOffset,
            $queryLimit,
            $descending
        );
 
        $this->extractResultInfo( $isFirst, $queryLimit, $this->mResult );
        $this->mQueryDone = true;
 
        $this->preprocessResults( $this->mResult );
        $this->mResult->rewind(); // Paranoia
 
        wfProfileOut( $fname );
    }
 
    function getResult() {
        return $this->mResult;
    }
 
    function setOffset( $offset ) {
        $this->mOffset = $offset;
    }
 
    function setLimit( $limit ) {
        $limit = (int)$limit;
        // WebRequest::getLimitOffset() puts a cap of 5000, so do same here.
        if ( $limit > 5000 ) {
            $limit = 5000;
        }
        if ( $limit > 0 ) {
            $this->mLimit = $limit;
        }
    }
 
    function getLimit() {
        return $this->mLimit;
    }
 
    public function setIncludeOffset( $include ) {
        $this->mIncludeOffset = $include;
    }
 
    function extractResultInfo( $isFirst, $limit, ResultWrapper $res ) {
        $numRows = $res->numRows();
        if ( $numRows ) {
            # Remove any table prefix from index field
            $parts = explode( '.', $this->mIndexField );
            $indexColumn = end( $parts );
 
            $row = $res->fetchRow();
            $firstIndex = $row[$indexColumn];
 
            # Discard the extra result row if there is one
            if ( $numRows > $this->mLimit && $numRows > 1 ) {
                $res->seek( $numRows - 1 );
                $this->mPastTheEndRow = $res->fetchObject();
                $this->mPastTheEndIndex = $this->mPastTheEndRow->$indexColumn;
                $res->seek( $numRows - 2 );
                $row = $res->fetchRow();
                $lastIndex = $row[$indexColumn];
            } else {
                $this->mPastTheEndRow = null;
                # Setting indexes to an empty string means that they will be
                # omitted if they would otherwise appear in URLs. It just so
                # happens that this  is the right thing to do in the standard
                # UI, in all the relevant cases.
                $this->mPastTheEndIndex = '';
                $res->seek( $numRows - 1 );
                $row = $res->fetchRow();
                $lastIndex = $row[$indexColumn];
            }
        } else {
            $firstIndex = '';
            $lastIndex = '';
            $this->mPastTheEndRow = null;
            $this->mPastTheEndIndex = '';
        }
 
        if ( $this->mIsBackwards ) {
            $this->mIsFirst = ( $numRows < $limit );
            $this->mIsLast = $isFirst;
            $this->mLastShown = $firstIndex;
            $this->mFirstShown = $lastIndex;
        } else {
            $this->mIsFirst = $isFirst;
            $this->mIsLast = ( $numRows < $limit );
            $this->mLastShown = $lastIndex;
            $this->mFirstShown = $firstIndex;
        }
    }
 
    function getSqlComment() {
        return get_class( $this );
    }
 
    public function reallyDoQuery( $offset, $limit, $descending ) {
        list( $tables, $fields, $conds, $fname, $options, $join_conds ) = $this->buildQueryInfo( $offset, $limit, $descending );
        return $this->mDb->select( $tables, $fields, $conds, $fname, $options, $join_conds );
    }
 
    protected function buildQueryInfo( $offset, $limit, $descending ) {
        $fname = __METHOD__ . ' (' . $this->getSqlComment() . ')';
        $info = $this->getQueryInfo();
        $tables = $info['tables'];
        $fields = $info['fields'];
        $conds = isset( $info['conds'] ) ? $info['conds'] : array();
        $options = isset( $info['options'] ) ? $info['options'] : array();
        $join_conds = isset( $info['join_conds'] ) ? $info['join_conds'] : array();
        $sortColumns = array_merge( array( $this->mIndexField ), $this->mExtraSortFields );
        if ( $descending ) {
            $options['ORDER BY'] = $sortColumns;
            $operator = $this->mIncludeOffset ? '>=' : '>';
        } else {
            $orderBy = array();
            foreach ( $sortColumns as $col ) {
                $orderBy[] = $col . ' DESC';
            }
            $options['ORDER BY'] = $orderBy;
            $operator = $this->mIncludeOffset ? '<=' : '<';
        }
        if ( $offset != '' ) {
            $conds[] = $this->mIndexField . $operator . $this->mDb->addQuotes( $offset );
        }
        $options['LIMIT'] = intval( $limit );
        return array( $tables, $fields, $conds, $fname, $options, $join_conds );
    }
 
    protected function preprocessResults( $result ) {}
 
    public function getBody() {
        if ( !$this->mQueryDone ) {
            $this->doQuery();
        }
 
        if ( $this->mResult->numRows() ) {
            # Do any special query batches before display
            $this->doBatchLookups();
        }
 
        # Don't use any extra rows returned by the query
        $numRows = min( $this->mResult->numRows(), $this->mLimit );
 
        $s = $this->getStartBody();
        if ( $numRows ) {
            if ( $this->mIsBackwards ) {
                for ( $i = $numRows - 1; $i >= 0; $i-- ) {
                    $this->mResult->seek( $i );
                    $row = $this->mResult->fetchObject();
                    $s .= $this->formatRow( $row );
                }
            } else {
                $this->mResult->seek( 0 );
                for ( $i = 0; $i < $numRows; $i++ ) {
                    $row = $this->mResult->fetchObject();
                    $s .= $this->formatRow( $row );
                }
            }
        } else {
            $s .= $this->getEmptyBody();
        }
        $s .= $this->getEndBody();
        return $s;
    }
 
    function makeLink( $text, array $query = null, $type = null ) {
        if ( $query === null ) {
            return $text;
        }
 
        $attrs = array();
        if ( in_array( $type, array( 'first', 'prev', 'next', 'last' ) ) ) {
            # HTML5 rel attributes
            $attrs['rel'] = $type;
        }
 
        if ( $type ) {
            $attrs['class'] = "mw-{$type}link";
        }
 
        return Linker::linkKnown(
            $this->getTitle(),
            $text,
            $attrs,
            $query + $this->getDefaultQuery()
        );
    }
 
    protected function doBatchLookups() {}
 
    protected function getStartBody() {
        return '';
    }
 
    protected function getEndBody() {
        return '';
    }
 
    protected function getEmptyBody() {
        return '';
    }
 
    function getDefaultQuery() {
        if ( !isset( $this->mDefaultQuery ) ) {
            $this->mDefaultQuery = $this->getRequest()->getQueryValues();
            unset( $this->mDefaultQuery['title'] );
            unset( $this->mDefaultQuery['dir'] );
            unset( $this->mDefaultQuery['offset'] );
            unset( $this->mDefaultQuery['limit'] );
            unset( $this->mDefaultQuery['order'] );
            unset( $this->mDefaultQuery['month'] );
            unset( $this->mDefaultQuery['year'] );
        }
        return $this->mDefaultQuery;
    }
 
    function getNumRows() {
        if ( !$this->mQueryDone ) {
            $this->doQuery();
        }
        return $this->mResult->numRows();
    }
 
    function getPagingQueries() {
        if ( !$this->mQueryDone ) {
            $this->doQuery();
        }
 
        # Don't announce the limit everywhere if it's the default
        $urlLimit = $this->mLimit == $this->mDefaultLimit ? null : $this->mLimit;
 
        if ( $this->mIsFirst ) {
            $prev = false;
            $first = false;
        } else {
            $prev = array(
                'dir' => 'prev',
                'offset' => $this->mFirstShown,
                'limit' => $urlLimit
            );
            $first = array( 'limit' => $urlLimit );
        }
        if ( $this->mIsLast ) {
            $next = false;
            $last = false;
        } else {
            $next = array( 'offset' => $this->mLastShown, 'limit' => $urlLimit );
            $last = array( 'dir' => 'prev', 'limit' => $urlLimit );
        }
        return array(
            'prev' => $prev,
            'next' => $next,
            'first' => $first,
            'last' => $last
        );
    }
 
    function isNavigationBarShown() {
        if ( !$this->mQueryDone ) {
            $this->doQuery();
        }
        // Hide navigation by default if there is nothing to page
        return !( $this->mIsFirst && $this->mIsLast );
    }
 
    function getPagingLinks( $linkTexts, $disabledTexts = array() ) {
        $queries = $this->getPagingQueries();
        $links = array();
 
        foreach ( $queries as $type => $query ) {
            if ( $query !== false ) {
                $links[$type] = $this->makeLink(
                    $linkTexts[$type],
                    $queries[$type],
                    $type
                );
            } elseif ( isset( $disabledTexts[$type] ) ) {
                $links[$type] = $disabledTexts[$type];
            } else {
                $links[$type] = $linkTexts[$type];
            }
        }
 
        return $links;
    }
 
    function getLimitLinks() {
        $links = array();
        if ( $this->mIsBackwards ) {
            $offset = $this->mPastTheEndIndex;
        } else {
            $offset = $this->mOffset;
        }
        foreach ( $this->mLimitsShown as $limit ) {
            $links[] = $this->makeLink(
                $this->getLanguage()->formatNum( $limit ),
                array( 'offset' => $offset, 'limit' => $limit ),
                'num'
            );
        }
        return $links;
    }
 
    abstract function formatRow( $row );
 
    abstract function getQueryInfo();
 
    abstract function getIndexField();
 
    protected function getExtraSortFields() {
        return array();
    }
 
    protected function getDefaultDirections() {
        return false;
    }
}
 
abstract class AlphabeticPager extends IndexPager {
 
    function getNavigationBar() {
        if ( !$this->isNavigationBarShown() ) {
            return '';
        }
 
        if ( isset( $this->mNavigationBar ) ) {
            return $this->mNavigationBar;
        }
 
        $linkTexts = array(
            'prev' => $this->msg( 'prevn' )->numParams( $this->mLimit )->escaped(),
            'next' => $this->msg( 'nextn' )->numParams( $this->mLimit )->escaped(),
            'first' => $this->msg( 'page_first' )->escaped(),
            'last' => $this->msg( 'page_last' )->escaped()
        );
 
        $lang = $this->getLanguage();
 
        $pagingLinks = $this->getPagingLinks( $linkTexts );
        $limitLinks = $this->getLimitLinks();
        $limits = $lang->pipeList( $limitLinks );
 
        $this->mNavigationBar = $this->msg( 'parentheses' )->rawParams(
            $lang->pipeList( array( $pagingLinks['first'],
            $pagingLinks['last'] ) ) )->escaped() . " " .
            $this->msg( 'viewprevnext' )->rawParams( $pagingLinks['prev'],
                $pagingLinks['next'], $limits )->escaped();
 
        if ( !is_array( $this->getIndexField() ) ) {
            # Early return to avoid undue nesting
            return $this->mNavigationBar;
        }
 
        $extra = '';
        $first = true;
        $msgs = $this->getOrderTypeMessages();
        foreach ( array_keys( $msgs ) as $order ) {
            if ( $first ) {
                $first = false;
            } else {
                $extra .= $this->msg( 'pipe-separator' )->escaped();
            }
 
            if ( $order == $this->mOrderType ) {
                $extra .= $this->msg( $msgs[$order] )->escaped();
            } else {
                $extra .= $this->makeLink(
                    $this->msg( $msgs[$order] )->escaped(),
                    array( 'order' => $order )
                );
            }
        }
 
        if ( $extra !== '' ) {
            $extra = ' ' . $this->msg( 'parentheses' )->rawParams( $extra )->escaped();
            $this->mNavigationBar .= $extra;
        }
 
        return $this->mNavigationBar;
    }
 
    protected function getOrderTypeMessages() {
        return null;
    }
}
 
abstract class ReverseChronologicalPager extends IndexPager {
    public $mDefaultDirection = true;
    public $mYear;
    public $mMonth;
 
    function getNavigationBar() {
        if ( !$this->isNavigationBarShown() ) {
            return '';
        }
 
        if ( isset( $this->mNavigationBar ) ) {
            return $this->mNavigationBar;
        }
 
        $linkTexts = array(
            'prev' => $this->msg( 'pager-newer-n' )->numParams( $this->mLimit )->escaped(),
            'next' => $this->msg( 'pager-older-n' )->numParams( $this->mLimit )->escaped(),
            'first' => $this->msg( 'histlast' )->escaped(),
            'last' => $this->msg( 'histfirst' )->escaped()
        );
 
        $pagingLinks = $this->getPagingLinks( $linkTexts );
        $limitLinks = $this->getLimitLinks();
        $limits = $this->getLanguage()->pipeList( $limitLinks );
        $firstLastLinks = $this->msg( 'parentheses' )->rawParams( "{$pagingLinks['first']}" .
            $this->msg( 'pipe-separator' )->escaped() .
            "{$pagingLinks['last']}" )->escaped();
 
        $this->mNavigationBar = $firstLastLinks . ' ' .
            $this->msg( 'viewprevnext' )->rawParams(
                $pagingLinks['prev'], $pagingLinks['next'], $limits )->escaped();
 
        return $this->mNavigationBar;
    }
 
    function getDateCond( $year, $month ) {
        $year = intval( $year );
        $month = intval( $month );
 
        // Basic validity checks
        $this->mYear = $year > 0 ? $year : false;
        $this->mMonth = ( $month > 0 && $month < 13 ) ? $month : false;
 
        // Given an optional year and month, we need to generate a timestamp
        // to use as "WHERE rev_timestamp <= result"
        // Examples: year = 2006 equals < 20070101 (+000000)
        // year=2005, month=1    equals < 20050201
        // year=2005, month=12   equals < 20060101
        if ( !$this->mYear && !$this->mMonth ) {
            return;
        }
 
        if ( $this->mYear ) {
            $year = $this->mYear;
        } else {
            // If no year given, assume the current one
            $timestamp = MWTimestamp::getInstance();
            $year = $timestamp->format( 'Y' );
            // If this month hasn't happened yet this year, go back to last year's month
            if ( $this->mMonth > $timestamp->format( 'n' ) ) {
                $year--;
            }
        }
 
        if ( $this->mMonth ) {
            $month = $this->mMonth + 1;
            // For December, we want January 1 of the next year
            if ( $month > 12 ) {
                $month = 1;
                $year++;
            }
        } else {
            // No month implies we want up to the end of the year in question
            $month = 1;
            $year++;
        }
 
        // Y2K38 bug
        if ( $year > 2032 ) {
            $year = 2032;
        }
 
        $ymd = (int)sprintf( "%04d%02d01", $year, $month );
 
        if ( $ymd > 20320101 ) {
            $ymd = 20320101;
        }
 
        $this->mOffset = $this->mDb->timestamp( "${ymd}000000" );
    }
}
 
abstract class TablePager extends IndexPager {
    var $mSort;
    var $mCurrentRow;
 
    public function __construct( IContextSource $context = 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 = false;
        } elseif ( $this->getRequest()->getBool( 'desc' ) ) {
            $this->mDefaultDirection = true;
        } /* Else leave it at whatever the class default is */
 
        parent::__construct();
    }
 
    function getStartBody() {
        global $wgStylePath;
        $sortClass = $this->getSortHeaderClass();
 
        $s = '';
        $fields = $this->getFieldNames();
 
        # Make table header
        foreach ( $fields as $field => $name ) {
            if ( strval( $name ) == '' ) {
                $s .= Html::rawElement( 'th', array(), '&#160;' ) . "\n";
            } elseif ( $this->isFieldSortable( $field ) ) {
                $query = array( 'sort' => $field, 'limit' => $this->mLimit );
                if ( $field == $this->mSort ) {
                    # This is the sorted column
                    # Prepare a link that goes in the other sort order
                    if ( $this->mDefaultDirection ) {
                        # Descending
                        $image = 'Arr_d.png';
                        $query['asc'] = '1';
                        $query['desc'] = '';
                        $alt = $this->msg( 'descending_abbrev' )->escaped();
                    } else {
                        # Ascending
                        $image = 'Arr_u.png';
                        $query['asc'] = '';
                        $query['desc'] = '1';
                        $alt = $this->msg( 'ascending_abbrev' )->escaped();
                    }
                    $image = "$wgStylePath/common/images/$image";
                    $link = $this->makeLink(
                        Html::element( 'img', array( 'width' => 12, 'height' => 12,
                            'alt' => $alt, 'src' => $image ) ) . htmlspecialchars( $name ), $query );
                    $s .= Html::rawElement( 'th', array( 'class' => $sortClass ), $link ) . "\n";
                } else {
                    $s .= Html::rawElement( 'th', array(),
                        $this->makeLink( htmlspecialchars( $name ), $query ) ) . "\n";
                }
            } else {
                $s .= Html::element( 'th', array(), $name ) . "\n";
            }
        }
 
        $tableClass = $this->getTableClass();
        $ret = Html::openElement( 'table', array( 'style' => 'border:1px;', 'class' => "mw-datatable $tableClass" ) );
        $ret .= Html::rawElement( 'thead', array(), Html::rawElement( 'tr', array(), "\n" . $s . "\n" ) );
        $ret .= Html::openElement( 'tbody' ) . "\n";
 
        return $ret;
    }
 
    function getEndBody() {
        return "</tbody></table>\n";
    }
 
    function getEmptyBody() {
        $colspan = count( $this->getFieldNames() );
        $msgEmpty = $this->msg( 'table_pager_empty' )->text();
        return Html::rawElement( 'tr', array(),
            Html::element( 'td', array( 'colspan' => $colspan ), $msgEmpty ) );
    }
 
    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 = isset( $row->$field ) ? $row->$field : null;
            $formatted = strval( $this->formatValue( $field, $value ) );
 
            if ( $formatted == '' ) {
                $formatted = '&#160;';
            }
 
            $s .= Html::rawElement( 'td', $this->getCellAttrs( $field, $value ), $formatted ) . "\n";
        }
 
        $s .= Html::closeElement( 'tr' ) . "\n";
 
        return $s;
    }
 
    function getRowClass( $row ) {
        return '';
    }
 
    function getRowAttrs( $row ) {
        $class = $this->getRowClass( $row );
        if ( $class === '' ) {
            // Return an empty array to avoid clutter in HTML like class=""
            return array();
        } else {
            return array( 'class' => $this->getRowClass( $row ) );
        }
    }
 
    function getCellAttrs( $field, $value ) {
        return array( 'class' => 'TablePager_col_' . $field );
    }
 
    function getIndexField() {
        return $this->mSort;
    }
 
    function getTableClass() {
        return 'TablePager';
    }
 
    function getNavClass() {
        return 'TablePager_nav';
    }
 
    function getSortHeaderClass() {
        return 'TablePager_sort';
    }
 
    public function getNavigationBar() {
        global $wgStylePath;
 
        if ( !$this->isNavigationBarShown() ) {
            return '';
        }
 
        $path = "$wgStylePath/common/images";
        $labels = array(
            'first' => 'table_pager_first',
            'prev' => 'table_pager_prev',
            'next' => 'table_pager_next',
            'last' => 'table_pager_last',
        );
        $images = array(
            'first' => 'arrow_first_25.png',
            'prev' => 'arrow_left_25.png',
            'next' => 'arrow_right_25.png',
            'last' => 'arrow_last_25.png',
        );
        $disabledImages = array(
            'first' => 'arrow_disabled_first_25.png',
            'prev' => 'arrow_disabled_left_25.png',
            'next' => 'arrow_disabled_right_25.png',
            'last' => 'arrow_disabled_last_25.png',
        );
        if ( $this->getLanguage()->isRTL() ) {
            $keys = array_keys( $labels );
            $images = array_combine( $keys, array_reverse( $images ) );
            $disabledImages = array_combine( $keys, array_reverse( $disabledImages ) );
        }
 
        $linkTexts = array();
        $disabledTexts = array();
        foreach ( $labels as $type => $label ) {
            $msgLabel = $this->msg( $label )->escaped();
            $linkTexts[$type] = Html::element( 'img', array( 'src' => "$path/{$images[$type]}",
                'alt' => $msgLabel ) ) . "<br />$msgLabel";
            $disabledTexts[$type] = Html::element( 'img', array( 'src' => "$path/{$disabledImages[$type]}",
                'alt' => $msgLabel ) ) . "<br />$msgLabel";
        }
        $links = $this->getPagingLinks( $linkTexts, $disabledTexts );
 
        $s = Html::openElement( 'table', array( 'class' => $this->getNavClass() ) );
        $s .= Html::openElement( 'tr' ) . "\n";
        $width = 100 / count( $links ) . '%';
        foreach ( $labels as $type => $label ) {
            $s .= Html::rawElement( 'td', array( 'style' => "width:$width;" ), $links[$type] ) . "\n";
        }
        $s .= Html::closeElement( 'tr' ) . Html::closeElement( 'table' ) . "\n";
        return $s;
    }
 
    public function getLimitSelect( $attribs = array() ) {
        $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 = array();
        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;
    }
 
    function getHiddenFields( $blacklist = array() ) {
        $blacklist = (array)$blacklist;
        $query = $this->getRequest()->getQueryValues();
        foreach ( $blacklist as $name ) {
            unset( $query[$name] );
        }
        $s = '';
        foreach ( $query as $name => $value ) {
            $s .= Html::hidden( $name, $value ) . "\n";
        }
        return $s;
    }
 
    function getLimitForm() {
        global $wgScript;
 
        return Html::rawElement(
            'form',
            array(
                'method' => 'get',
                'action' => $wgScript
            ),
            "\n" . $this->getLimitDropdown()
        ) . "\n";
    }
 
    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( array( 'limit' ) );
    }
 
    abstract function isFieldSortable( $field );
 
    abstract function formatValue( $name, $value );
 
    abstract function getDefaultSort();
 
    abstract function getFieldNames();
}