X-Git-Url: https://git.heureux-cyclage.org/?a=blobdiff_plain;f=includes%2FOutputPage.php;h=0677495ac850a2df83a0ff976fef1324662083bd;hb=c03a4e321498d5cb2644d8706f93cd749355cf2f;hp=3843787c8be36c57c1de105d172c794c6302beec;hpb=1e4165061b83f99fbcf173b3ca908bef23c08108;p=lhc%2Fweb%2Fwiklou.git

diff --git a/includes/OutputPage.php b/includes/OutputPage.php
index 3843787c8b..0677495ac8 100644
--- a/includes/OutputPage.php
+++ b/includes/OutputPage.php
@@ -12,25 +12,22 @@ class OutputPage {
 	var $mHTMLtitle = '', $mIsarticle = true, $mPrintable = false;
 	var $mSubtitle = '', $mRedirect = '', $mStatusCode;
 	var $mLastModified = '', $mETag = false;
-	var $mCategoryLinks = array(), $mLanguageLinks = array();
-
-	var $mScriptLoaderClassList = array();
-
-	// The most recent revision ID of any wikiPage script that is grouped in the script request
-	var $mLatestScriptRevID = 0;
+	var $mCategoryLinks = array(), $mCategories = array(), $mLanguageLinks = array();
 
 	var $mScripts = '', $mLinkColours, $mPageLinkTitle = '', $mHeadItems = array();
+	var $mInlineMsg = array();
+
 	var $mTemplateIds = array();
 
 	var $mAllowUserJs;
 	var $mSuppressQuickbar = false;
-	var $mOnloadHandler = '';
 	var $mDoNothing = false;
 	var $mContainsOldMagic = 0, $mContainsNewMagic = 0;
 	var $mIsArticleRelated = true;
 	protected $mParserOptions = null; // lazy initialised, use parserOptions()
-	var $mShowFeedLinks = false;
-	var $mFeedLinksAppendQuery = false;
+
+	var $mFeedLinks = array();
+
 	var $mEnableClientCache = true;
 	var $mArticleBodyOnly = false;
 
@@ -50,8 +47,16 @@ class OutputPage {
 	 */
 	var $styles = array();
 
+	/**
+	 * Whether to load jQuery core.
+	 */
+	protected $mJQueryDone = false;
+
 	private $mIndexPolicy = 'index';
 	private $mFollowPolicy = 'follow';
+	private $mVaryHeader = array( 'Accept-Encoding' => array('list-contains=gzip'),
+								  'Cookie' => null );
+
 
 	/**
 	 * Constructor
@@ -62,12 +67,23 @@ class OutputPage {
 		$this->mAllowUserJs = $wgAllowUserJs;
 	}
 
+	/**
+	 * Redirect to $url rather than displaying the normal page
+	 *
+	 * @param $url String: URL
+	 * @param $responsecode String: HTTP status code
+	 */
 	public function redirect( $url, $responsecode = '302' ) {
 		# Strip newlines as a paranoia check for header injection in PHP<5.1.2
 		$this->mRedirect = str_replace( "\n", '', $url );
 		$this->mRedirectCode = $responsecode;
 	}
 
+	/**
+	 * Get the URL to redirect to, or an empty string if not redirect URL set
+	 *
+	 * @return String
+	 */
 	public function getRedirect() {
 		return $this->mRedirect;
 	}
@@ -75,10 +91,13 @@ class OutputPage {
 	/**
 	 * Set the HTTP status code to send with the output.
 	 *
-	 * @param int $statusCode
+	 * @param $statusCode Integer
 	 * @return nothing
 	 */
-	function setStatusCode( $statusCode ) { $this->mStatusCode = $statusCode; }
+	public function setStatusCode( $statusCode ) {
+		$this->mStatusCode = $statusCode;
+	}
+
 
 	/**
 	 * Add a new <meta> tag
@@ -91,231 +110,113 @@ class OutputPage {
 		array_push( $this->mMetatags, array( $name, $val ) );
 	}
 
+	/**
+	 * Add a keyword or a list of keywords in the page header
+	 *
+	 * @param $text String or array of strings
+	 */
 	function addKeyword( $text ) {
-		if( is_array( $text )) {
+		if( is_array( $text ) ) {
 			$this->mKeywords = array_merge( $this->mKeywords, $text );
 		} else {
 			array_push( $this->mKeywords, $text );
 		}
 	}
-	function addScript( $script ) {
-		$this->mScripts .= $script . "\n";
-	}
 
 	/**
-	 * Register and add a stylesheet from an extension directory.
-	 * @param $url String path to sheet.  Provide either a full url (beginning
-	 *             with 'http', etc) or a relative path from the document root
-	 *             (beginning with '/').  Otherwise it behaves identically to
-	 *             addStyle() and draws from the /skins folder.
+	 * Add a new \<link\> tag to the page header
+	 *
+	 * @param $linkarr Array: associative array of attributes.
 	 */
-	public function addExtensionStyle( $url ) {
-		array_push( $this->mExtStyles, $url );
+	function addLink( $linkarr ) {
+		array_push( $this->mLinktags, $linkarr );
 	}
 
 	/**
-	 * Add a JavaScript file out of skins/common, or a given relative path.
-	 * @param string $file filename in skins/common or complete on-server path (/foo/bar.js)
+	 * Add a new \<link\> with "rel" attribute set to "meta"
+	 *
+	 * @param $linkarr Array: associative array mapping attribute names to their
+	 *                 values, both keys and values will be escaped, and the
+	 *                 "rel" attribute will be automatically added
 	 */
-	function addScriptFile( $file ) {
-		global $wgStylePath, $wgScript, $wgUser;
-		global $wgJSAutoloadClasses, $wgJSAutoloadLocalClasses, $wgEnableScriptLoader, $wgScriptPath;
-
-		if( substr( $file, 0, 1 ) == '/' ) {
-			$path = $file;
-		} else {
-			$path = "{$wgStylePath}/common/{$file}";
-		}
-
-		if( $wgEnableScriptLoader ) {
-			if( strpos( $path, $wgScript ) !== false ) {
-				$reqPath = str_replace( $wgScript . '?', '', $path );
-				$reqArgs = explode( '&', $reqPath );
-				$reqSet = array();
-
-				foreach( $reqArgs as $arg ) {
-					list( $key, $var ) = explode( '=', $arg );
-					$reqSet[$key] = $var;
-				}
-
-				if( isset( $reqSet['title'] ) && $reqSet != '' ) {
-					// Extract any extra parameters (for now just skin)
-					$ext_param = ( isset( $reqSet['useskin'] ) && $reqSet['useskin'] != '' )
-						? '|useskin=' . ucfirst( $reqSet['useskin'] ) : '';
-					$this->mScriptLoaderClassList[] = 'WT:' . $reqSet['title'] . $ext_param ;
-					// Add the title revision to the key.
-					// If there is no title, we will just use $wgStyleVersion, 
-					// which should be updated on the relevant commits.
-					$t = Title::newFromText( $reqSet['title'] );
-					if( $t && $t->exists() ) {
-						if( $t->getLatestRevID() > $this->mLatestScriptRevID  )
-							$this->mLatestScriptRevID = $t->getLatestRevID();
-					}
-					return true;
-				}
-			}
-
-			// If the class can be determined, add it to the class list to be loaded later
-			$js_class = $this->getJsClassFromPath( $path );
-			if( $js_class ) {
-				$this->mScriptLoaderClassList[] = $js_class;
-				return true;
-			}
-		}
-
-		// If the script loader could not be used, just add the script to the header
-		$this->addScript( Html::linkedScript( wfAppendQuery( $path, $this->getURIDparam() ) ) );
+	function addMetadataLink( $linkarr ) {
+		# note: buggy CC software only reads first "meta" link
+		static $haveMeta = false;
+		$linkarr['rel'] = $haveMeta ? 'alternate meta' : 'meta';
+		$this->addLink( $linkarr );
+		$haveMeta = true;
 	}
 
-	/**
-	 * Add the core scripts that are included on every page, for later output into the header
-	 */
-	function addCoreScripts2Top(){
-		global $wgEnableScriptLoader, $wgJSAutoloadLocalClasses, $wgScriptPath, $wgEnableJS2system;
-		// @todo We should deprecate wikibits in favor of mv_embed and jQuery
-
-		if( $wgEnableJS2system ){
-			$core_classes = array( 'window.jQuery', 'mv_embed', 'wikibits' );
-		} else {
-			$core_classes = array( 'wikibits' );
-		}
-
-		if( $wgEnableScriptLoader ){
-			$this->mScripts = $this->getScriptLoaderJs( $core_classes ) . $this->mScripts;
-		} else {
-			$so = '';
-			foreach( $core_classes as $s ){
-				if( isset( $wgJSAutoloadLocalClasses[$s] ) ){
-					$so .= Html::linkedScript( "{$wgScriptPath}/{$wgJSAutoloadLocalClasses[$s]}?" . $this->getURIDparam() );
-				}
-			}
-			$this->mScripts =  $so . $this->mScripts;
-		}
-	}
 
 	/**
-	 * @param $js_class string Name of the JavaScript class
-	 * @return boolean False if the class wasn't found, true on success
+	 * Add raw HTML to the list of scripts (including \<script\> tag, etc.)
+	 *
+	 * @param $script String: raw HTML
 	 */
-	function addScriptClass( $js_class ){
-		global $wgDebugJavaScript, $wgJSAutoloadLocalClasses, $wgJSAutoloadClasses,
-				$wgEnableScriptLoader, $wgStyleVersion, $wgScriptPath;
-
-		if( isset( $wgJSAutoloadClasses[$js_class] ) 
-			|| isset( $wgJSAutoloadLocalClasses[$js_class] ) ) 
-		{
-			if( $wgEnableScriptLoader ) {
-				// Register it with the script loader
-				if( !in_array( $js_class, $this->mScriptLoaderClassList ) ) {
-					$this->mScriptLoaderClassList[] = $js_class;
-				}
-			} else {
-				// Source the script directly
-				$path = $wgScriptPath . '/';
-				if( isset( $wgJSAutoloadClasses[$js_class] ) ) {
-					$path .= $wgJSAutoloadClasses[$js_class];
-				} elseif( isset( $wgJSAutoloadLocalClasses[$js_class] ) ) {
-					$path .= $wgJSAutoloadLocalClasses[$js_class];
-				}
-				$urlAppend = ( $wgDebugJavaScript ) ? time() : $wgStyleVersion;
-				$this->addScript( Html::linkedScript( "$path?$urlAppend" ) );
-			}
-			return true;
-		}
-		wfDebug( __METHOD__ . ' could not find js_class: ' . $js_class );
-		return false; // could not find the class
+	function addScript( $script ) {
+		$this->mScripts .= $script . "\n";
 	}
 
 	/**
-	 * Get the <script> tag which will invoke the script loader
-	 * @param $classAry A class array which, if given, overrides $this->mScriptLoaderClassList
+	 * Register and add a stylesheet from an extension directory.
+	 *
+	 * @param $url String path to sheet.  Provide either a full url (beginning
+	 *             with 'http', etc) or a relative path from the document root
+	 *             (beginning with '/').  Otherwise it behaves identically to
+	 *             addStyle() and draws from the /skins folder.
 	 */
-	function getScriptLoaderJs( $classAry = array() ) {
-		global $wgRequest, $wgDebugJavaScript;
-		// If no class array was provided, use mScriptLoaderClassList
-		if( !count( $classAry ) ) {
-			$classAry = $this->mScriptLoaderClassList;
-		}
-		$class_list = implode( ',', $classAry );
-
-		$debug_param = ( $wgDebugJavaScript ||
-						 $wgRequest->getVal( 'debug' ) == 'true' ||
-						 $wgRequest->getVal( 'debug' ) == '1' )
-			 		 ? '&debug=true' : '';
-
-		return Html::linkedScript( wfScript( 'mwScriptLoader' ) . 
-			"?class={$class_list}{$debug_param}&" . $this->getURIDparam( $classAry) );
+	public function addExtensionStyle( $url ) {
+		array_push( $this->mExtStyles, $url );
 	}
 
 	/**
-	 * Get the unique request ID parameter for the script-loader request
+	 * Get all links added by extensions
+	 *
+	 * @return Array
 	 */
-	function getURIDparam( $classAry = array() ) {
-		global $wgDebugJavaScript, $wgStyleVersion, $IP, $wgScriptModifiedCheck;
-		if( $wgDebugJavaScript ) {
-			return 'urid=' . time();
-		} else {
-			$ftime=0;
-			if($wgScriptModifiedCheck) {
-				foreach( $classAry as $class ) {
-					$js_path =  jsScriptLoader::getJsPathFromClass( $class );
-					if( $js_path ) {
-						$cur_ftime = filemtime ( $IP ."/". $js_path );
-						if( $cur_ftime > $ftime )
-							$ftime = $cur_ftime;
-					}
-				}
-			}
-			$urid = "urid={$wgStyleVersion}";
-
-			// Add the latest revision ID if we have it
-			if($this->mLatestScriptRevID != 0 )
-				$urid .= "_{$this->mLatestScriptRevID}";
-
-			// Add the file modification time
-			if( $ftime != 0 )
-				$urid .= "_".$ftime;
-
-			return $urid;
-		}
+	function getExtStyle() {
+		return $this->mExtStyles;
 	}
 
 	/**
-	 * Given a script path, get the JS class name, or false if no such path is registered.
-	 * @param $path string
+	 * Add a JavaScript file out of skins/common, or a given relative path.
+	 *
+	 * @param $file String: filename in skins/common or complete on-server path
+	 *              (/foo/bar.js)
 	 */
-	function getJsClassFromPath( $path ) {
-		global $wgJSAutoloadClasses, $wgJSAutoloadLocalClasses, $wgScriptPath;
-
-		$scriptLoaderPaths = array_merge( $wgJSAutoloadClasses,  $wgJSAutoloadLocalClasses );
-		foreach( $scriptLoaderPaths as $js_class => $js_path ) {
-			$js_path = "{$wgScriptPath}/{$js_path}";
-			if( $path == $js_path )
-				return $js_class;
+	public function addScriptFile( $file ) {
+		global $wgStylePath, $wgStyleVersion;
+		if( substr( $file, 0, 1 ) == '/' || substr( $file, 0, 7 ) == 'http://' ) {
+			$path = $file;
+		} else {
+			$path =  "{$wgStylePath}/common/{$file}";
 		}
-		return false;
+		$this->addScript( Html::linkedScript( wfAppendQuery( $path, $wgStyleVersion ) ) );
 	}
 
 	/**
 	 * Add a self-contained script tag with the given contents
-	 * @param string $script JavaScript text, no <script> tags
+	 *
+	 * @param $script String: JavaScript text, no <script> tags
 	 */
-	function addInlineScript( $script ) {
+	public function addInlineScript( $script ) {
 		$this->mScripts .= Html::inlineScript( "\n$script\n" ) . "\n";
 	}
 
 	/**
 	 * Get all registered JS and CSS tags for the header.
+	 *
+	 * @return String
 	 */
 	function getScript() {
-		global $wgEnableScriptLoader;
-		if( $wgEnableScriptLoader ){
-			return $this->mScripts . "\n" . $this->getScriptLoaderJs() . $this->getHeadItems();
-		} else {
-			return $this->mScripts . $this->getHeadItems();
-		}
+		return $this->mScripts . $this->getHeadItems();
 	}
 
+	/**
+	 * Get all header items in a string
+	 *
+	 * @return String
+	 */
 	function getHeadItems() {
 		$s = '';
 		foreach ( $this->mHeadItems as $item ) {
@@ -324,36 +225,56 @@ class OutputPage {
 		return $s;
 	}
 
-	function addHeadItem( $name, $value ) {
+	/**
+	 * Add or replace an header item to the output
+	 *
+	 * @param $name String: item name
+	 * @param $value String: raw HTML
+	 */
+	public function addHeadItem( $name, $value ) {
 		$this->mHeadItems[$name] = $value;
 	}
 
-	function hasHeadItem( $name ) {
+	/**
+	 * Check if the header item $name is already set
+	 *
+	 * @param $name String: item name
+	 * @return Boolean
+	 */
+	public function hasHeadItem( $name ) {
 		return isset( $this->mHeadItems[$name] );
 	}
 
-	function setETag($tag) { $this->mETag = $tag; }
-	function setArticleBodyOnly($only) { $this->mArticleBodyOnly = $only; }
-	function getArticleBodyOnly() { return $this->mArticleBodyOnly; }
-
-	function addLink( $linkarr ) {
-		# $linkarr should be an associative array of attributes. We'll escape on output.
-		array_push( $this->mLinktags, $linkarr );
+	/**
+	 * Set the value of the ETag HTTP header, only used if $wgUseETag is true
+	 *
+	 * @param $tag String: value of "ETag" header
+	 */
+	function setETag( $tag ) {
+		$this->mETag = $tag;
 	}
 
-	# Get all links added by extensions
-	function getExtStyle() {
-		return $this->mExtStyles;
+	/**
+	 * Set whether the output should only contain the body of the article,
+	 * without any skin, sidebar, etc.
+	 * Used e.g. when calling with "action=render".
+	 *
+	 * @param $only Boolean: whether to output only the body of the article
+	 */
+	public function setArticleBodyOnly( $only ) {
+		$this->mArticleBodyOnly = $only;
 	}
 
-	function addMetadataLink( $linkarr ) {
-		# note: buggy CC software only reads first "meta" link
-		static $haveMeta = false;
-		$linkarr['rel'] = ($haveMeta) ? 'alternate meta' : 'meta';
-		$this->addLink( $linkarr );
-		$haveMeta = true;
+	/**
+	 * Return whether the output will contain only the body of the article
+	 *
+	 * @return Boolean
+	 */
+	public function getArticleBodyOnly() {
+		return $this->mArticleBodyOnly;
 	}
 
+
 	/**
 	 * checkLastModified tells the client to use the client-cached page if
 	 * possible. If sucessful, the OutputPage is disabled so that
@@ -361,9 +282,9 @@ class OutputPage {
 	 *
 	 * Side effect: sets mLastModified for Last-Modified header
 	 *
-	 * @return bool True iff cache-ok headers was sent.
+	 * @return Boolean: true iff cache-ok headers was sent.
 	 */
-	function checkLastModified( $timestamp ) {
+	public function checkLastModified( $timestamp ) {
 		global $wgCachePages, $wgCacheEpoch, $wgUser, $wgRequest;
 
 		if ( !$timestamp || $timestamp == '19700101000000' ) {
@@ -443,20 +364,11 @@ class OutputPage {
 		return true;
 	}
 
-	function setPageTitleActionText( $text ) {
-		$this->mPageTitleActionText = $text;
-	}
-
-	function getPageTitleActionText () {
-		if ( isset( $this->mPageTitleActionText ) ) {
-			return $this->mPageTitleActionText;
-		}
-	}
 
 	/**
 	 * Set the robot policy for the page: <http://www.robotstxt.org/meta.html>
 	 *
-	 * @param $policy string The literal string to output as the contents of
+	 * @param $policy String: the literal string to output as the contents of
 	 *   the meta tag.  Will be parsed according to the spec and output in
 	 *   standardized form.
 	 * @return null
@@ -466,10 +378,10 @@ class OutputPage {
 
 		if( isset( $policy['index'] ) ){
 			$this->setIndexPolicy( $policy['index'] );
- 		}
+		}
 		if( isset( $policy['follow'] ) ){
 			$this->setFollowPolicy( $policy['follow'] );
- 		}
+		}
 	}
 
 	/**
@@ -490,7 +402,7 @@ class OutputPage {
 	 * Set the follow policy for the page, but leave the index policy un-
 	 * touched.
 	 *
-	 * @param $policy string Either 'follow' or 'nofollow'.
+	 * @param $policy String: either 'follow' or 'nofollow'.
 	 * @return null
 	 */
 	public function setFollowPolicy( $policy ) {
@@ -500,6 +412,28 @@ class OutputPage {
 		}
 	}
 
+
+	/**
+	 * Set the new value of the "action text", this will be added to the
+	 * "HTML title", separated from it with " - ".
+	 *
+	 * @param $text String: new value of the "action text"
+	 */
+	public function setPageTitleActionText( $text ) {
+		$this->mPageTitleActionText = $text;
+	}
+
+	/**
+	 * Get the value of the "action text"
+	 *
+	 * @return String
+	 */
+	public function getPageTitleActionText() {
+		if ( isset( $this->mPageTitleActionText ) ) {
+			return $this->mPageTitleActionText;
+		}
+	}
+
 	/**
 	 * "HTML title" means the contents of <title>. It is stored as plain, unescaped text and will be run through htmlspecialchars in the skin file.
 	 */
@@ -508,14 +442,21 @@ class OutputPage {
 	}
 
 	/**
-	 * "Page title" means the contents of <h1>. It is stored as a valid HTML fragment.
-	 * This function allows good tags like <sup> in the <h1> tag, but not bad tags like <script>.
-	 * This function automatically sets <title> to the same content as <h1> but with all tags removed.
-	 * Bad tags that were escaped in <h1> will still be escaped in <title>, and good tags like <i> will be dropped entirely.
-         */
+	 * Return the "HTML title", i.e. the content of the <title> tag.
+	 *
+	 * @return String
+	 */
+	public function getHTMLTitle() {
+		return $this->mHTMLtitle;
+	}
+
+	/**
+	 * "Page title" means the contents of \<h1\>. It is stored as a valid HTML fragment.
+	 * This function allows good tags like \<sup\> in the \<h1\> tag, but not bad tags like \<script\>.
+	 * This function automatically sets \<title\> to the same content as \<h1\> but with all tags removed.
+	 * Bad tags that were escaped in \<h1\> will still be escaped in \<title\>, and good tags like \<i\> will be dropped entirely.
+	 */
 	public function setPageTitle( $name ) {
-		global $wgContLang;
-		$name = $wgContLang->convert( $name, true );
 		# change "<script>foo&bar</script>" to "&lt;script&gt;foo&amp;bar&lt;/script&gt;"
 		# but leave "<i>foobar</i>" alone
 		$nameWithTags = Sanitizer::normalizeCharReferences( Sanitizer::removeHTMLtags( $name ) );
@@ -530,44 +471,202 @@ class OutputPage {
 		$this->setHTMLTitle( wfMsg( 'pagetitle', Sanitizer::stripAllTags( $nameWithTags ) ) );
 	}
 
+	/**
+	 * Return the "page title", i.e. the content of the \<h1\> tag.
+	 *
+	 * @return String
+	 */
+	public function getPageTitle() {
+		return $this->mPagetitle;
+	}
+
+	/**
+	 * Set the Title object to use
+	 *
+	 * @param $t Title object
+	 */
 	public function setTitle( $t ) {
 		$this->mTitle = $t;
 	}
 
+	/**
+	 * Get the Title object used in this instance
+	 *
+	 * @return Title
+	 */
 	public function getTitle() {
 		if ( $this->mTitle instanceof Title ) {
 			return $this->mTitle;
-		}
-		else {
+		} else {
 			wfDebug( __METHOD__ . ' called and $mTitle is null. Return $wgTitle for sanity' );
 			global $wgTitle;
 			return $wgTitle;
 		}
 	}
 
-	public function getHTMLTitle() { return $this->mHTMLtitle; }
-	public function getPageTitle() { return $this->mPagetitle; }
-	public function setSubtitle( $str ) { $this->mSubtitle = /*$this->parse(*/$str/*)*/; } // @bug 2514
-	public function appendSubtitle( $str ) { $this->mSubtitle .= /*$this->parse(*/$str/*)*/; } // @bug 2514
-	public function getSubtitle() { return $this->mSubtitle; }
-	public function isArticle() { return $this->mIsarticle; }
-	public function setPrintable() { $this->mPrintable = true; }
-	public function isPrintable() { return $this->mPrintable; }
-	public function setSyndicated( $show = true ) { $this->mShowFeedLinks = $show; }
-	public function isSyndicated() { return $this->mShowFeedLinks; }
-	public function setFeedAppendQuery( $val ) { $this->mFeedLinksAppendQuery = $val; }
-	public function getFeedAppendQuery() { return $this->mFeedLinksAppendQuery; }
-	public function setOnloadHandler( $js ) { $this->mOnloadHandler = $js; }
-	public function getOnloadHandler() { return $this->mOnloadHandler; }
-	public function disable() { $this->mDoNothing = true; }
-	public function isDisabled() { return $this->mDoNothing; }
+	/**
+	 * Replace the subtile with $str
+	 *
+	 * @param $str String: new value of the subtitle
+	 */
+	public function setSubtitle( $str ) {
+		$this->mSubtitle = /*$this->parse(*/ $str /*)*/; // @bug 2514
+	}
 
-	public function setArticleRelated( $v ) {
-		$this->mIsArticleRelated = $v;
-		if ( !$v ) {
-			$this->mIsarticle = false;
+	/**
+	 * Add $str to the subtitle
+	 *
+	 * @param $str String to add to the subtitle
+	 */
+	public function appendSubtitle( $str ) {
+		$this->mSubtitle .= /*$this->parse(*/ $str /*)*/; // @bug 2514
+	}
+
+	/**
+	 * Get the subtitle
+	 *
+	 * @return String
+	 */
+	public function getSubtitle() {
+		return $this->mSubtitle;
+	}
+
+
+	/**
+	 * Set the page as printable, i.e. it'll be displayed with with all
+	 * print styles included
+	 */
+	public function setPrintable() {
+		$this->mPrintable = true;
+	}
+
+	/**
+	 * Return whether the page is "printable"
+	 *
+	 * @return Boolean
+	 */
+	public function isPrintable() {
+		return $this->mPrintable;
+	}
+
+
+	/**
+	 * Disable output completely, i.e. calling output() will have no effect
+	 */
+	public function disable() {
+		$this->mDoNothing = true;
+	}
+
+	/**
+	 * Return whether the output will be completely disabled
+	 *
+	 * @return Boolean
+	 */
+	public function isDisabled() {
+		return $this->mDoNothing;
+	}
+
+
+	/**
+	 * Show an "add new section" link?
+	 *
+	 * @return Boolean
+	 */
+	public function showNewSectionLink() {
+		return $this->mNewSectionLink;
+	}
+
+	/**
+	 * Forcibly hide the new section link?
+	 *
+	 * @return Boolean
+	 */
+	public function forceHideNewSectionLink() {
+		return $this->mHideNewSectionLink;
+	}
+
+
+	/**
+	 * Add or remove feed links in the page header
+	 * This is mainly kept for backward compatibility, see OutputPage::addFeedLink()
+	 * for the new version
+	 * @see addFeedLink()
+	 *
+	 * @param $show Boolean: true: add default feeds, false: remove all feeds
+	 */
+	public function setSyndicated( $show = true ) {
+		if ( $show ) {
+			$this->setFeedAppendQuery( false );
+		} else {
+			$this->mFeedLinks = array();
+		}
+	}
+
+	/**
+	 * Add default feeds to the page header
+	 * This is mainly kept for backward compatibility, see OutputPage::addFeedLink()
+	 * for the new version
+	 * @see addFeedLink()
+	 *
+	 * @param $val String: query to append to feed links or false to output
+	 *        default links
+	 */
+	public function setFeedAppendQuery( $val ) {
+		global $wgAdvertisedFeedTypes;
+
+		$this->mFeedLinks = array();
+
+		foreach ( $wgAdvertisedFeedTypes as $type ) {
+			$query = "feed=$type";
+			if ( is_string( $val ) ) {
+				$query .= '&' . $val;
+			}
+			$this->mFeedLinks[$type] = $this->getTitle()->getLocalURL( $query );
 		}
 	}
+
+	/**
+	 * Add a feed link to the page header
+	 *
+	 * @param $format String: feed type, should be a key of $wgFeedClasses
+	 * @param $href String: URL
+	 */
+	public function addFeedLink( $format, $href ) {
+		$this->mFeedLinks[$format] = $href;
+	}
+
+	/**
+	 * Should we output feed links for this page?
+	 * @return Boolean
+	 */
+	public function isSyndicated() {
+		return count( $this->mFeedLinks ) > 0;
+	}
+
+	/**
+	 * Return URLs for each supported syndication format for this page.
+	 * @return array associating format keys with URLs
+	 */
+	public function getSyndicationLinks() {
+		return $this->mFeedLinks;
+	}
+
+	/**
+	 * Will currently always return null
+	 *
+	 * @return null
+	 */
+	public function getFeedAppendQuery() {
+		return $this->mFeedLinksAppendQuery;
+	}
+
+	/**
+	 * Set whether the displayed content is related to the source of the
+	 * corresponding article on the wiki
+	 * Setting true will cause the change "article related" toggle to true
+	 *
+	 * @param $v Boolean
+	 */
 	public function setArticleFlag( $v ) {
 		$this->mIsarticle = $v;
 		if ( $v ) {
@@ -575,22 +674,73 @@ class OutputPage {
 		}
 	}
 
-	public function isArticleRelated() { return $this->mIsArticleRelated; }
+	/**
+	 * Return whether the content displayed page is related to the source of
+	 * the corresponding article on the wiki
+	 *
+	 * @return Boolean
+	 */
+	public function isArticle() {
+		return $this->mIsarticle;
+	}
 
-	public function getLanguageLinks() { return $this->mLanguageLinks; }
-	public function addLanguageLinks($newLinkArray) {
+	/**
+	 * Set whether this page is related an article on the wiki
+	 * Setting false will cause the change of "article flag" toggle to false
+	 *
+	 * @param $v Boolean
+	 */
+	public function setArticleRelated( $v ) {
+		$this->mIsArticleRelated = $v;
+		if ( !$v ) {
+			$this->mIsarticle = false;
+		}
+	}
+
+	/**
+	 * Return whether this page is related an article on the wiki
+	 *
+	 * @return Boolean
+	 */
+	public function isArticleRelated() {
+		return $this->mIsArticleRelated;
+	}
+
+
+	/**
+	 * Add new language links
+	 *
+	 * @param $newLinkArray Associative array mapping language code to the page
+	 *                      name
+	 */
+	public function addLanguageLinks( $newLinkArray ) {
 		$this->mLanguageLinks += $newLinkArray;
 	}
-	public function setLanguageLinks($newLinkArray) {
+
+	/**
+	 * Reset the language links and add new language links
+	 *
+	 * @param $newLinkArray Associative array mapping language code to the page
+	 *                      name
+	 */
+	public function setLanguageLinks( $newLinkArray ) {
 		$this->mLanguageLinks = $newLinkArray;
 	}
 
-	public function getCategoryLinks() {
-		return $this->mCategoryLinks;
+	/**
+	 * Get the list of language links
+	 *
+	 * @return Associative array mapping language code to the page name
+	 */
+	public function getLanguageLinks() {
+		return $this->mLanguageLinks;
 	}
 
+
 	/**
 	 * Add an array of categories, with names in the keys
+	 *
+	 * @param $categories Associative array mapping category name to its sort key
 	 */
 	public function addCategoryLinks( $categories ) {
 		global $wgUser, $wgContLang;
@@ -638,34 +788,139 @@ class OutputPage {
 					if ( array_key_exists( $category, $categories ) )
 						continue;
 				$text = $wgContLang->convertHtml( $title->getText() );
+				$this->mCategories[] = $title->getText();
 				$this->mCategoryLinks[$type][] = $sk->link( $title, $text );
 			}
 		}
 	}
 
-	public function setCategoryLinks($categories) {
+	/**
+	 * Reset the category links (but not the category list) and add $categories
+	 *
+	 * @param $categories Associative array mapping category name to its sort key
+	 */
+	public function setCategoryLinks( $categories ) {
 		$this->mCategoryLinks = array();
-		$this->addCategoryLinks($categories);
+		$this->addCategoryLinks( $categories );
 	}
 
-	public function suppressQuickbar() { $this->mSuppressQuickbar = true; }
-	public function isQuickbarSuppressed() { return $this->mSuppressQuickbar; }
+	/**
+	 * Get the list of category links, in a 2-D array with the following format:
+	 * $arr[$type][] = $link, where $type is either "normal" or "hidden" (for
+	 * hidden categories) and $link a HTML fragment with a link to the category
+	 * page
+	 *
+	 * @return Array
+	 */
+	public function getCategoryLinks() {
+		return $this->mCategoryLinks;
+	}
 
-	public function disallowUserJs() { $this->mAllowUserJs = false; }
-	public function isUserJsAllowed() { return $this->mAllowUserJs; }
+	/**
+	 * Get the list of category names this page belongs to
+	 *
+	 * @return Array of strings
+	 */
+	public function getCategories() {
+		return $this->mCategories;
+	}
 
-	public function prependHTML( $text ) { $this->mBodytext = $text . $this->mBodytext; }
-	public function addHTML( $text ) { $this->mBodytext .= $text; }
-	public function clearHTML() { $this->mBodytext = ''; }
-	public function getHTML() { return $this->mBodytext; }
-	public function debug( $text ) { $this->mDebugtext .= $text; }
 
-	/* @deprecated */
+	/**
+	 * Suppress the quickbar from the output, only for skin supporting
+	 * the quickbar
+	 */
+	public function suppressQuickbar() {
+		$this->mSuppressQuickbar = true;
+	}
+
+	/**
+	 * Return whether the quickbar should be suppressed from the output
+	 *
+	 * @return Boolean
+	 */
+	public function isQuickbarSuppressed() {
+		return $this->mSuppressQuickbar;
+	}
+
+
+	/**
+	 * Remove user JavaScript from scripts to load
+	 */
+	public function disallowUserJs() {
+		$this->mAllowUserJs = false;
+	}
+
+	/**
+	 * Return whether user JavaScript is allowed for this page
+	 *
+	 * @return Boolean
+	 */
+	public function isUserJsAllowed() {
+		return $this->mAllowUserJs;
+	}
+
+
+	/**
+	 * Prepend $text to the body HTML
+	 *
+	 * @param $text String: HTML
+	 */
+	public function prependHTML( $text ) {
+		$this->mBodytext = $text . $this->mBodytext;
+	}
+
+	/**
+	 * Append $text to the body HTML
+	 *
+	 * @param $text String: HTML
+	 */
+	public function addHTML( $text ) {
+		$this->mBodytext .= $text;
+	}
+
+	/**
+	 * Clear the body HTML
+	 */
+	public function clearHTML() {
+		$this->mBodytext = '';
+	}
+
+	/**
+	 * Get the body HTML
+	 *
+	 * @return String: HTML
+	 */
+	public function getHTML() {
+		return $this->mBodytext;
+	}
+
+
+	/**
+	 * Add $text to the debug output
+	 *
+	 * @param $text String: debug text
+	 */
+	public function debug( $text ) {
+		$this->mDebugtext .= $text;
+	}
+
+
+	/**
+	 * @deprecated use parserOptions() instead
+	 */
 	public function setParserOptions( $options ) {
 		wfDeprecated( __METHOD__ );
 		return $this->parserOptions( $options );
 	}
 
+	/**
+	 * Get/set the ParserOptions object to use for wikitext parsing
+	 *
+	 * @param $options either the ParserOption to use or null to only get the
+	 *                 current ParserOption object
+	 * @return current ParserOption object
+	 */
 	public function parserOptions( $options = null ) {
 		if ( !$this->mParserOptions ) {
 			$this->mParserOptions = new ParserOptions;
@@ -676,40 +931,78 @@ class OutputPage {
 	/**
 	 * Set the revision ID which will be seen by the wiki text parser
 	 * for things such as embedded {{REVISIONID}} variable use.
-	 * @param mixed $revid an integer, or NULL
-	 * @return mixed previous value
+	 *
+	 * @param $revid Mixed: an positive integer, or null
+	 * @return Mixed: previous value
 	 */
 	public function setRevisionId( $revid ) {
 		$val = is_null( $revid ) ? null : intval( $revid );
 		return wfSetVar( $this->mRevisionId, $val );
 	}
 
+	/**
+	 * Get the current revision ID
+	 *
+	 * @return Integer
+	 */
 	public function getRevisionId() {
 		return $this->mRevisionId;
 	}
 
 	/**
 	 * Convert wikitext to HTML and add it to the buffer
-	 * Default assumes that the current page title will
-	 * be used.
+	 * Default assumes that the current page title will be used.
 	 *
-	 * @param string $text
-	 * @param bool   $linestart
+	 * @param $text String
+	 * @param $linestart Boolean: is this the start of a line?
 	 */
 	public function addWikiText( $text, $linestart = true ) {
 		$title = $this->getTitle(); // Work arround E_STRICT
 		$this->addWikiTextTitle( $text, $title, $linestart );
 	}
 
-	public function addWikiTextWithTitle($text, &$title, $linestart = true) {
-		$this->addWikiTextTitle($text, $title, $linestart);
+	/**
+	 * Add wikitext with a custom Title object
+	 *
+	 * @param $text String: wikitext
+	 * @param $title Title object
+	 * @param $linestart Boolean: is this the start of a line?
+	 */
+	public function addWikiTextWithTitle( $text, &$title, $linestart = true ) {
+		$this->addWikiTextTitle( $text, $title, $linestart );
 	}
 
-	function addWikiTextTitleTidy($text, &$title, $linestart = true) {
+	/**
+	 * Add wikitext with a custom Title object and 
+	 *
+	 * @param $text String: wikitext
+	 * @param $title Title object
+	 * @param $linestart Boolean: is this the start of a line?
+	 */
+	function addWikiTextTitleTidy( $text, &$title, $linestart = true ) {
 		$this->addWikiTextTitle( $text, $title, $linestart, true );
 	}
 
-	public function addWikiTextTitle($text, &$title, $linestart, $tidy = false) {
+	/**
+	 * Add wikitext with tidy enabled
+	 *
+	 * @param $text String: wikitext
+	 * @param $linestart Boolean: is this the start of a line?
+	 */
+	public function addWikiTextTidy( $text, $linestart = true ) {
+		$title = $this->getTitle();
+		$this->addWikiTextTitleTidy($text, $title, $linestart);
+	}
+
+	/**
+	 * Add wikitext with a custom Title object
+	 *
+	 * @param $text String: wikitext
+	 * @param $title Title object
+	 * @param $linestart Boolean: is this the start of a line?
+	 * @param $tidy Boolean: whether to use tidy
+	 */
+	public function addWikiTextTitle( $text, &$title, $linestart, $tidy = false ) {
 		global $wgParser;
 
 		wfProfileIn( __METHOD__ );
@@ -730,8 +1023,45 @@ class OutputPage {
 	}
 
 	/**
-	 * @todo document
-	 * @param ParserOutput object &$parserOutput
+	 * Add wikitext to the buffer, assuming that this is the primary text for a page view
+	 * Saves the text into the parser cache if possible.
+	 *
+	 * @param $text String: wikitext
+	 * @param $article Article object
+	 * @param $cache Boolean
+	 * @deprecated Use Article::outputWikitext
+	 */
+	public function addPrimaryWikiText( $text, $article, $cache = true ) {
+		global $wgParser;
+
+		wfDeprecated( __METHOD__ );
+
+		$popts = $this->parserOptions();
+		$popts->setTidy(true);
+		$parserOutput = $wgParser->parse( $text, $article->mTitle,
+			$popts, true, true, $this->mRevisionId );
+		$popts->setTidy(false);
+		if ( $cache && $article && $parserOutput->getCacheTime() != -1 ) {
+			$parserCache = ParserCache::singleton();
+			$parserCache->save( $parserOutput, $article, $popts);
+		}
+
+		$this->addParserOutput( $parserOutput );
+	}
+
+	/**
+	 * @deprecated use addWikiTextTidy()
+	 */
+	public function addSecondaryWikiText( $text, $linestart = true ) {
+		wfDeprecated( __METHOD__ );
+		$this->addWikiTextTitleTidy($text, $this->getTitle(), $linestart);
+	}
+
+
+	/**
+	 * Add a ParserOutput object, but without Html
+	 *
+	 * @param $parserOutput ParserOutput object
 	 */
 	public function addParserOutputNoText( &$parserOutput ) {
 		global $wgExemptFromUserRobotsControl, $wgContentNamespaces;
@@ -746,7 +1076,7 @@ class OutputPage {
 			$this->enableClientCache( false );
 		}
 		$this->mNoGallery = $parserOutput->getNoGallery();
-		$this->mHeadItems = array_merge( $this->mHeadItems, (array)$parserOutput->mHeadItems );
+		$this->mHeadItems = array_merge( $this->mHeadItems, $parserOutput->getHeadItems() );
 		// Versioning...
 		foreach ( (array)$parserOutput->mTemplateIds as $ns => $dbks ) {
 			if ( isset( $this->mTemplateIds[$ns] ) ) {
@@ -756,10 +1086,10 @@ class OutputPage {
 			}
 		}
 		// Page title
-		if( ( $dt = $parserOutput->getDisplayTitle() ) !== false )
-			$this->setPageTitle( $dt );
-		else if ( ( $title = $parserOutput->getTitleText() ) != '' )
+		$title = $parserOutput->getTitleText();
+		if ( $title != '' ) {
 			$this->setPageTitle( $title );
+		}
 
 		// Hooks registered in the object
 		global $wgParserOutputHooks;
@@ -774,64 +1104,22 @@ class OutputPage {
 	}
 
 	/**
-	 * @todo document
-	 * @param ParserOutput &$parserOutput
+	 * Add a ParserOutput object
+	 *
+	 * @param $parserOutput ParserOutput
 	 */
 	function addParserOutput( &$parserOutput ) {
 		$this->addParserOutputNoText( $parserOutput );
-		$text =	$parserOutput->getText();
+		$text = $parserOutput->getText();
 		wfRunHooks( 'OutputPageBeforeHTML',array( &$this, &$text ) );
 		$this->addHTML( $text );
 	}
 
-	/**
-	 * Add wikitext to the buffer, assuming that this is the primary text for a page view
-	 * Saves the text into the parser cache if possible.
-	 *
-	 * @param string  $text
-	 * @param Article $article
-	 * @param bool    $cache
-	 * @deprecated Use Article::outputWikitext
-	 */
-	public function addPrimaryWikiText( $text, $article, $cache = true ) {
-		global $wgParser;
-
-		wfDeprecated( __METHOD__ );
-
-		$popts = $this->parserOptions();
-		$popts->setTidy(true);
-		$parserOutput = $wgParser->parse( $text, $article->mTitle,
-			$popts, true, true, $this->mRevisionId );
-		$popts->setTidy(false);
-		if ( $cache && $article && $parserOutput->getCacheTime() != -1 ) {
-			$parserCache = ParserCache::singleton();
-			$parserCache->save( $parserOutput, $article, $popts);
-		}
-
-		$this->addParserOutput( $parserOutput );
-	}
-
-	/**
-	 * @deprecated use addWikiTextTidy()
-	 */
-	public function addSecondaryWikiText( $text, $linestart = true ) {
-		wfDeprecated( __METHOD__ );
-		$this->addWikiTextTitleTidy($text, $this->getTitle(), $linestart);
-	}
-
-	/**
-	 * Add wikitext with tidy enabled
-	 */
-	public function addWikiTextTidy(  $text, $linestart = true ) {
-		$title = $this->getTitle();
-		$this->addWikiTextTitleTidy($text, $title, $linestart);
-	}
-
 
 	/**
 	 * Add the output of a QuickTemplate to the output buffer
 	 *
-	 * @param QuickTemplate $template
+	 * @param $template QuickTemplate
 	 */
 	public function addTemplate( &$template ) {
 		ob_start();
@@ -843,9 +1131,12 @@ class OutputPage {
 	/**
 	 * Parse wikitext and return the HTML.
 	 *
-	 * @param string $text
-	 * @param bool   $linestart Is this the start of a line?
-	 * @param bool   $interface ??
+	 * @param $text String
+	 * @param $linestart Boolean: is this the start of a line?
+	 * @param $interface Boolean: use interface language ($wgLang instead of
+	 *                   $wgContLang) while parsing language sensitive magic
+	 *                   words like GRAMMAR and PLURAL
+	 * @return String: HTML
 	 */
 	public function parse( $text, $linestart = true, $interface = false ) {
 		global $wgParser;
@@ -860,7 +1151,16 @@ class OutputPage {
 		return $parserOutput->getText();
 	}
 
-	/** Parse wikitext, strip paragraphs, and return the HTML. */
+	/**
+	 * Parse wikitext, strip paragraphs, and return the HTML.
+	 *
+	 * @param $text String
+	 * @param $linestart Boolean: is this the start of a line?
+	 * @param $interface Boolean: use interface language ($wgLang instead of
+	 *                   $wgContLang) while parsing language sensitive magic
+	 *                   words like GRAMMAR and PLURAL
+	 * @return String: HTML
+	 */
 	public function parseInline( $text, $linestart = true, $interface = false ) {
 		$parsed = $this->parse( $text, $linestart, $interface );
 
@@ -873,12 +1173,10 @@ class OutputPage {
 	}
 
 	/**
-	 * @param Article $article
-	 * @param User    $user
-	 *
 	 * @deprecated
 	 *
-	 * @return bool True if successful, else false.
+	 * @param $article Article
+	 * @return Boolean: true if successful, else false.
 	 */
 	public function tryParserCache( &$article ) {
 		wfDeprecated( __METHOD__ );
@@ -893,7 +1191,9 @@ class OutputPage {
 	}
 
 	/**
-	 * @param int $maxage Maximum cache time on the Squid, in seconds.
+	 * Set the value of the "s-maxage" part of the "Cache-control" HTTP header
+	 *
+	 * @param $maxage Integer: maximum cache time on the Squid, in seconds.
 	 */
 	public function setSquidMaxage( $maxage ) {
 		$this->mSquidMaxage = $maxage;
@@ -901,12 +1201,18 @@ class OutputPage {
 
 	/**
 	 * Use enableClientCache(false) to force it to send nocache headers
+	 *
 	 * @param $state ??
 	 */
 	public function enableClientCache( $state ) {
 		return wfSetVar( $this->mEnableClientCache, $state );
 	}
 
+	/**
+	 * Get the list of cookies that will influence on the cache
+	 *
+	 * @return Array
+	 */
 	function getCacheVaryCookies() {
 		global $wgCookiePrefix, $wgCacheVaryCookies;
 		static $cookies;
@@ -924,15 +1230,23 @@ class OutputPage {
 		return $cookies;
 	}
 
+	/**
+	 * Return whether this page is not cacheable because "useskin" or "uselang"
+	 * url parameters were passed
+	 *
+	 * @return Boolean
+	 */
 	function uncacheableBecauseRequestVars() {
 		global $wgRequest;
-		return	$wgRequest->getText('useskin', false) === false
+		return $wgRequest->getText('useskin', false) === false
 			&& $wgRequest->getText('uselang', false) === false;
 	}
 
 	/**
 	 * Check if the request has a cache-varying cookie header
 	 * If it does, it's very important that we don't allow public caching
+	 *
+	 * @return Boolean
 	 */
 	function haveCacheVaryCookies() {
 		global $wgRequest;
@@ -952,22 +1266,81 @@ class OutputPage {
 		return false;
 	}
 
-	/** Get a complete X-Vary-Options header */
+	/**
+	 * Add an HTTP header that will influence on the cache
+	 *
+	 * @param $header String: header name
+	 * @param $option either an Array or null
+	 */
+	public function addVaryHeader( $header, $option = null ) {
+		if ( !array_key_exists( $header, $this->mVaryHeader ) ) {
+			$this->mVaryHeader[$header] = $option;
+		}
+		elseif( is_array( $option ) ) {
+			if( is_array( $this->mVaryHeader[$header] ) ) {
+				$this->mVaryHeader[$header] = array_merge( $this->mVaryHeader[$header], $option );
+			}
+			else {
+				$this->mVaryHeader[$header] = $option;
+			}
+		}
+		$this->mVaryHeader[$header] = array_unique( $this->mVaryHeader[$header] );
+	}
+
+	/**
+	 * Get a complete X-Vary-Options header
+	 *
+	 * @return String
+	 */
 	public function getXVO() {
 		$cvCookies = $this->getCacheVaryCookies();
-		$xvo = 'X-Vary-Options: Accept-Encoding;list-contains=gzip,Cookie;';
-		$first = true;
+		
+		$cookiesOption = array();
 		foreach ( $cvCookies as $cookieName ) {
-			if ( $first ) {
-				$first = false;
-			} else {
-				$xvo .= ';';
+			$cookiesOption[] = 'string-contains=' . $cookieName;
+		}
+		$this->addVaryHeader( 'Cookie', $cookiesOption );
+		
+		$headers = array();
+		foreach( $this->mVaryHeader as $header => $option ) {
+			$newheader = $header;
+			if( is_array( $option ) )
+				$newheader .= ';' . implode( ';', $option );
+			$headers[] = $newheader;
+		}
+		$xvo = 'X-Vary-Options: ' . implode( ',', $headers );
+		
+		return $xvo;
+	}
+
+	/**
+	 * bug 21672: Add Accept-Language to Vary and XVO headers
+	 * if there's no 'variant' parameter existed in GET.
+	 *
+	 * For example:
+	 *   /w/index.php?title=Main_page should always be served; but
+	 *   /w/index.php?title=Main_page&variant=zh-cn should never be served.
+	 *
+	 * patched by Liangent and Philip
+	 */
+	function addAcceptLanguage() {
+		global $wgRequest, $wgContLang;
+		if( !$wgRequest->getCheck('variant') && $wgContLang->hasVariants() ) {
+			$variants = $wgContLang->getVariants();
+			$aloption = array();
+			foreach ( $variants as $variant ) {
+				if( $variant === $wgContLang->getCode() )
+					continue;
+				else
+					$aloption[] = "string-contains=$variant";
 			}
-			$xvo .= 'string-contains=' . $cookieName;
+			$this->addVaryHeader( 'Accept-Language', $aloption );
 		}
-		return $xvo;
 	}
 
+	/**
+	 * Send cache control HTTP headers
+	 */
 	public function sendCacheControl() {
 		global $wgUseSquid, $wgUseESI, $wgUseETag, $wgSquidMaxage, $wgRequest, $wgUseXVO;
 
@@ -975,9 +1348,11 @@ class OutputPage {
 		if ($wgUseETag && $this->mETag)
 			$response->header("ETag: $this->mETag");
 
+		$this->addAcceptLanguage();
+
 		# don't serve compressed data to clients who can't handle it
 		# maintain different caches for logged-in users and non-logged in ones
-		$response->header( 'Vary: Accept-Encoding, Cookie' );
+		$response->header( 'Vary: ' . join( ', ', array_keys( $this->mVaryHeader ) ) );
 
 		if ( $wgUseXVO ) {
 			# Add an X-Vary-Options header for Squid with Wikimedia patches
@@ -1028,6 +1403,65 @@ class OutputPage {
 		}
 	}
 
+	/**
+	 * Get the message associed with the HTTP response code $code
+	 *
+	 * @param $code Integer: status code
+	 * @return String or null: message or null if $code is not in the list of
+	 *         messages
+	 */
+	public static function getStatusMessage( $code ) {
+		static $statusMessage = array(
+			100 => 'Continue',
+			101 => 'Switching Protocols',
+			102 => 'Processing',
+			200 => 'OK',
+			201 => 'Created',
+			202 => 'Accepted',
+			203 => 'Non-Authoritative Information',
+			204 => 'No Content',
+			205 => 'Reset Content',
+			206 => 'Partial Content',
+			207 => 'Multi-Status',
+			300 => 'Multiple Choices',
+			301 => 'Moved Permanently',
+			302 => 'Found',
+			303 => 'See Other',
+			304 => 'Not Modified',
+			305 => 'Use Proxy',
+			307 => 'Temporary Redirect',
+			400 => 'Bad Request',
+			401 => 'Unauthorized',
+			402 => 'Payment Required',
+			403 => 'Forbidden',
+			404 => 'Not Found',
+			405 => 'Method Not Allowed',
+			406 => 'Not Acceptable',
+			407 => 'Proxy Authentication Required',
+			408 => 'Request Timeout',
+			409 => 'Conflict',
+			410 => 'Gone',
+			411 => 'Length Required',
+			412 => 'Precondition Failed',
+			413 => 'Request Entity Too Large',
+			414 => 'Request-URI Too Large',
+			415 => 'Unsupported Media Type',
+			416 => 'Request Range Not Satisfiable',
+			417 => 'Expectation Failed',
+			422 => 'Unprocessable Entity',
+			423 => 'Locked',
+			424 => 'Failed Dependency',
+			500 => 'Internal Server Error',
+			501 => 'Not Implemented',
+			502 => 'Bad Gateway',
+			503 => 'Service Unavailable',
+			504 => 'Gateway Timeout',
+			505 => 'HTTP Version Not Supported',
+			507 => 'Insufficient Storage'
+		);
+		return isset( $statusMessage[$code] ) ? $statusMessage[$code] : null;
+	}
+
 	/**
 	 * Finally, all the text has been munged and accumulated into
 	 * the object, let's actually output it:
@@ -1043,89 +1477,37 @@ class OutputPage {
 			return;
 		}
 		wfProfileIn( __METHOD__ );
-		if ( '' != $this->mRedirect ) {
+		if ( $this->mRedirect != '' ) {
 			# Standards require redirect URLs to be absolute
 			$this->mRedirect = wfExpandUrl( $this->mRedirect );
-			if( $this->mRedirectCode == '301') {
+			if( $this->mRedirectCode == '301' || $this->mRedirectCode == '303' ) {
 				if( !$wgDebugRedirects ) {
-					$wgRequest->response()->header("HTTP/1.1 {$this->mRedirectCode} Moved Permanently");
+					$message = self::getStatusMessage( $this->mRedirectCode );
+					$wgRequest->response()->header( "HTTP/1.1 {$this->mRedirectCode} $message" );
 				}
 				$this->mLastModified = wfTimestamp( TS_RFC2822 );
 			}
 			$this->sendCacheControl();
 
-			$wgRequest->response()->header("Content-Type: text/html; charset=utf-8");
+			$wgRequest->response()->header( "Content-Type: text/html; charset=utf-8" );
 			if( $wgDebugRedirects ) {
 				$url = htmlspecialchars( $this->mRedirect );
 				print "<html>\n<head>\n<title>Redirect</title>\n</head>\n<body>\n";
 				print "<p>Location: <a href=\"$url\">$url</a></p>\n";
 				print "</body>\n</html>\n";
 			} else {
-				$wgRequest->response()->header( 'Location: '.$this->mRedirect );
+				$wgRequest->response()->header( 'Location: ' . $this->mRedirect );
 			}
 			wfProfileOut( __METHOD__ );
 			return;
-		}
-		elseif ( $this->mStatusCode )
-		{
-			$statusMessage = array(
-				100 => 'Continue',
-				101 => 'Switching Protocols',
-				102 => 'Processing',
-				200 => 'OK',
-				201 => 'Created',
-				202 => 'Accepted',
-				203 => 'Non-Authoritative Information',
-				204 => 'No Content',
-				205 => 'Reset Content',
-				206 => 'Partial Content',
-				207 => 'Multi-Status',
-				300 => 'Multiple Choices',
-				301 => 'Moved Permanently',
-				302 => 'Found',
-				303 => 'See Other',
-				304 => 'Not Modified',
-				305 => 'Use Proxy',
-				307 => 'Temporary Redirect',
-				400 => 'Bad Request',
-				401 => 'Unauthorized',
-				402 => 'Payment Required',
-				403 => 'Forbidden',
-				404 => 'Not Found',
-				405 => 'Method Not Allowed',
-				406 => 'Not Acceptable',
-				407 => 'Proxy Authentication Required',
-				408 => 'Request Timeout',
-				409 => 'Conflict',
-				410 => 'Gone',
-				411 => 'Length Required',
-				412 => 'Precondition Failed',
-				413 => 'Request Entity Too Large',
-				414 => 'Request-URI Too Large',
-				415 => 'Unsupported Media Type',
-				416 => 'Request Range Not Satisfiable',
-				417 => 'Expectation Failed',
-				422 => 'Unprocessable Entity',
-				423 => 'Locked',
-				424 => 'Failed Dependency',
-				500 => 'Internal Server Error',
-				501 => 'Not Implemented',
-				502 => 'Bad Gateway',
-				503 => 'Service Unavailable',
-				504 => 'Gateway Timeout',
-				505 => 'HTTP Version Not Supported',
-				507 => 'Insufficient Storage'
-			);
-
-			if ( $statusMessage[$this->mStatusCode] )
-				$wgRequest->response()->header( 'HTTP/1.1 ' . $this->mStatusCode . ' ' . $statusMessage[$this->mStatusCode] );
+		} elseif ( $this->mStatusCode ) {
+			$message = self::getStatusMessage( $this->mStatusCode );
+			if ( $message )
+				$wgRequest->response()->header( 'HTTP/1.1 ' . $this->mStatusCode . ' ' . $message );
 		}
 
 		$sk = $wgUser->getSkin();
 
-		// Add our core scripts to output
-		$this->addCoreScripts2Top();
-
 		if ( $wgUseAjax ) {
 			$this->addScriptFile( 'ajax.js' );
 
@@ -1144,11 +1526,6 @@ class OutputPage {
 			$this->addScriptFile( 'rightclickedit.js' );
 		}
 
-		global $wgUseAJAXCategories;
-		if ($wgUseAJAXCategories) {
-			$this->addScriptClass( 'ajaxCategories' );
-		}
-
 		if( $wgUniversalEditButton ) {
 			if( isset( $wgArticle ) && $this->getTitle() && $this->getTitle()->quickUserCan( 'edit' )
 				&& ( $this->getTitle()->exists() || $this->getTitle()->quickUserCan( 'create' ) ) ) {
@@ -1195,7 +1572,8 @@ class OutputPage {
 	/**
 	 * Actually output something with print(). Performs an iconv to the
 	 * output encoding, if needed.
-	 * @param string $ins The string to output
+	 *
+	 * @param $ins String: the string to output
 	 */
 	public function out( $ins ) {
 		global $wgInputEncoding, $wgOutputEncoding, $wgContLang;
@@ -1225,9 +1603,9 @@ class OutputPage {
 	}
 
 	/**
-	 * Deprecated, use wfReportTime() instead.
-	 * @return string
-	 * @deprecated
+	 * @deprecated use wfReportTime() instead.
+	 *
+	 * @return String
 	 */
 	public function reportTime() {
 		wfDeprecated( __METHOD__ );
@@ -1238,7 +1616,7 @@ class OutputPage {
 	/**
 	 * Produce a "user is blocked" page.
 	 *
-	 * @param bool $return Whether to have a "return to $wgTitle" message or not.
+	 * @param $return Boolean: whether to have a "return to $wgTitle" message or not.
 	 * @return nothing
 	 */
 	function blockedPage( $return = true ) {
@@ -1300,9 +1678,9 @@ class OutputPage {
 	/**
 	 * Output a standard error page
 	 *
-	 * @param string $title Message key for page title
-	 * @param string $msg Message key for page text
-	 * @param array $params Message parameters
+	 * @param $title String: message key for page title
+	 * @param $msg String: message key for page text
+	 * @param $params Array: message parameters
 	 */
 	public function showErrorPage( $title, $msg, $params = array() ) {
 		if ( $this->getTitle() ) {
@@ -1326,10 +1704,10 @@ class OutputPage {
 	/**
 	 * Output a standard permission error page
 	 *
-	 * @param array $errors Error message keys
+	 * @param $errors Array: error message keys
+	 * @param $action String: action that was denied or null if unknown
 	 */
-	public function showPermissionsErrorPage( $errors, $action = null )
-	{
+	public function showPermissionsErrorPage( $errors, $action = null ) {
 		$this->mDebugtext .= 'Original title: ' .
 		$this->getTitle()->getPrefixedText() . "\n";
 		$this->setPageTitle( wfMsg( 'permissionserrors' ) );
@@ -1342,17 +1720,11 @@ class OutputPage {
 		$this->addWikiText( $this->formatPermissionsErrorMessage( $errors, $action ) );
 	}
 
-	/** @deprecated */
-	public function errorpage( $title, $msg ) {
-		wfDeprecated( __METHOD__ );
-		throw new ErrorPageError( $title, $msg );
-	}
-
 	/**
 	 * Display an error page indicating that a given version of MediaWiki is
 	 * required to use it
 	 *
-	 * @param mixed $version The version of MediaWiki needed to use the page
+	 * @param $version Mixed: the version of MediaWiki needed to use the page
 	 */
 	public function versionRequired( $version ) {
 		$this->setPageTitle( wfMsg( 'versionrequired', $version ) );
@@ -1368,7 +1740,7 @@ class OutputPage {
 	/**
 	 * Display an error page noting that a given permission bit is required.
 	 *
-	 * @param string $permission key required
+	 * @param $permission String: key required
 	 */
 	public function permissionRequired( $permission ) {
 		global $wgLang;
@@ -1392,16 +1764,14 @@ class OutputPage {
 	}
 
 	/**
-	 * Use permissionRequired.
-	 * @deprecated
+	 * @deprecated use permissionRequired()
 	 */
 	public function sysopRequired() {
 		throw new MWException( "Call to deprecated OutputPage::sysopRequired() method\n" );
 	}
 
 	/**
-	 * Use permissionRequired.
-	 * @deprecated
+	 * @deprecated use permissionRequired()
 	 */
 	public function developerRequired() {
 		throw new MWException( "Call to deprecated OutputPage::developerRequired() method\n" );
@@ -1443,14 +1813,12 @@ class OutputPage {
 			$this->returnToMain( null, $mainPage );
 	}
 
-	/** @deprecated */
-	public function databaseError( $fname, $sql, $error, $errno ) {
-		throw new MWException( "OutputPage::databaseError is obsolete\n" );
-	}
-
 	/**
-	 * @param array $errors An array of arrays returned by Title::getUserPermissionsErrors
-	 * @return string The wikitext error-messages, formatted into a list.
+	 * Format a list of error messages
+	 *
+	 * @param $errors An array of arrays returned by Title::getUserPermissionsErrors
+	 * @param $action String: action that was denied or null if unknown
+	 * @return String: the wikitext error-messages, formatted into a list.
 	 */
 	public function formatPermissionsErrorMessage( $errors, $action = null ) {
 		if ($action == null) {
@@ -1493,9 +1861,10 @@ class OutputPage {
 	 *
 	 * @todo Needs to be split into multiple functions.
 	 *
-	 * @param string $source    Source code to show (or null).
-	 * @param bool   $protected Is this a permissions error?
-	 * @param array  $reasons   List of reasons for this error, as returned by Title::getUserPermissionsErrors().
+	 * @param $source    String: source code to show (or null).
+	 * @param $protected Boolean: is this a permissions error?
+	 * @param $reasons   Array: list of reasons for this error, as returned by Title::getUserPermissionsErrors().
+	 * @param $action    String: action that was denied or null if unknown
 	 */
 	public function readOnlyPage( $source = null, $protected = false, $reasons = array(), $action = null ) {
 		global $wgUser;
@@ -1534,21 +1903,21 @@ class OutputPage {
 			// Wiki is read only
 			$this->setPageTitle( wfMsg( 'readonly' ) );
 			$reason = wfReadOnlyReason();
-			$this->wrapWikiMsg( '<div class="mw-readonly-error">$1</div>', array( 'readonlytext', $reason ) );
+			$this->wrapWikiMsg( '<div class="mw-readonly-error">\n$1</div>', array( 'readonlytext', $reason ) );
 		}
 
 		// Show source, if supplied
 		if( is_string( $source ) ) {
 			$this->addWikiMsg( 'viewsourcetext' );
-			$text = Xml::openElement( 'textarea',
-						array( 'id'   => 'wpTextbox1',
-						       'name' => 'wpTextbox1',
-						       'cols' => $wgUser->getOption( 'cols' ),
-						       'rows' => $wgUser->getOption( 'rows' ),
-						       'readonly' => 'readonly' ) );
-			$text .= htmlspecialchars( $source );
-			$text .= Xml::closeElement( 'textarea' );
-			$this->addHTML( $text );
+
+			$params = array(
+				'id'   => 'wpTextbox1',
+				'name' => 'wpTextbox1',
+				'cols' => $wgUser->getOption( 'cols' ),
+				'rows' => $wgUser->getOption( 'rows' ),
+				'readonly' => 'readonly'
+			);
+			$this->addHTML( Html::element( 'textarea', $params, $source ) );
 
 			// Show templates used by this article
 			$skin = $wgUser->getSkin();
@@ -1567,6 +1936,17 @@ class OutputPage {
 		}
 	}
 
+	/** @deprecated */
+	public function errorpage( $title, $msg ) {
+		wfDeprecated( __METHOD__ );
+		throw new ErrorPageError( $title, $msg );
+	}
+
+	/** @deprecated */
+	public function databaseError( $fname, $sql, $error, $errno ) {
+		throw new MWException( "OutputPage::databaseError is obsolete\n" );
+	}
+
 	/** @deprecated */
 	public function fatalError( $message ) {
 		wfDeprecated( __METHOD__ );
@@ -1635,8 +2015,8 @@ class OutputPage {
 	/**
 	 * Add a "return to" link pointing to a specified title
 	 *
-	 * @param Title $title Title to link
-	 * @param string $query Query string
+	 * @param $title Title to link
+	 * @param $query String: query string
 	 */
 	public function addReturnTo( $title, $query = array() ) {
 		global $wgUser;
@@ -1650,8 +2030,9 @@ class OutputPage {
 	 * Add a "return to" link pointing to a specified title,
 	 * or the title indicated in the request, or else the main page
 	 *
-	 * @param null $unused No longer used
-	 * @param Title $returnto Title to return to
+	 * @param $unused No longer used
+	 * @param $returnto Title or String to return to
+	 * @param $returntoquery String: query string for the return to link
 	 */
 	public function returnToMain( $unused = null, $returnto = null, $returntoquery = null ) {
 		global $wgRequest;
@@ -1664,7 +2045,7 @@ class OutputPage {
 			$returntoquery = $wgRequest->getText( 'returntoquery' );
 		}
 
-		if ( '' === $returnto ) {
+		if ( $returnto === '' ) {
 			$returnto = Title::newMainPage();
 		}
 
@@ -1681,12 +2062,15 @@ class OutputPage {
 	}
 
 	/**
-	 * @return string The doctype, opening <html>, and head element.
+	 * @param $sk Skin The given Skin
+	 * @param $includeStyle Unused (?)
+	 * @return String: The doctype, opening <html>, and head element.
 	 */
-	public function headElement( Skin $sk ) {
+	public function headElement( Skin $sk, $includeStyle = true ) {
 		global $wgDocType, $wgDTD, $wgContLanguageCode, $wgOutputEncoding, $wgMimeType;
-		global $wgXhtmlDefaultNamespace, $wgXhtmlNamespaces;
-		global $wgContLang, $wgUseTrackbacks, $wgStyleVersion, $wgEnableScriptLoader, $wgHtml5;
+		global $wgXhtmlDefaultNamespace, $wgXhtmlNamespaces, $wgHtml5Version;
+		global $wgContLang, $wgUseTrackbacks, $wgStyleVersion, $wgHtml5, $wgWellFormedXml;
+		global $wgUser, $wgRequest, $wgLang;
 
 		$this->addMeta( "http:Content-Type", "$wgMimeType; charset={$wgOutputEncoding}" );
 		if ( $sk->commonPrintStylesheet() ) {
@@ -1700,22 +2084,36 @@ class OutputPage {
 			$ret .= "<?xml version=\"1.0\" encoding=\"$wgOutputEncoding\" ?" . ">\n";
 		}
 
-		if ( '' == $this->getHTMLTitle() ) {
+		if ( $this->getHTMLTitle() == '' ) {
 			$this->setHTMLTitle(  wfMsg( 'pagetitle', $this->getPageTitle() ));
 		}
 
 		$dir = $wgContLang->getDir();
 
 		if ( $wgHtml5 ) {
-			$ret .= "<!doctype html>\n";
-			$ret .= "<html lang=\"$wgContLanguageCode\" dir=\"$dir\">\n";
+			if ( $wgWellFormedXml ) {
+				# Unknown elements and attributes are okay in XML, but unknown
+				# named entities are well-formedness errors and will break XML
+				# parsers.  Thus we need a doctype that gives us appropriate
+				# entity definitions.  The HTML5 spec permits four legacy
+				# doctypes as obsolete but conforming, so let's pick one of
+				# those, although it makes our pages look like XHTML1 Strict.
+				# Isn't compatibility great?
+				$ret .= "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n";
+			} else {
+				# Much saner.
+				$ret .= "<!doctype html>\n";
+			}
+			$ret .= "<html lang=\"$wgContLanguageCode\" dir=\"$dir\"";
+			if ( $wgHtml5Version ) $ret .= " version=\"$wgHtml5Version\"";
+			$ret .= ">\n";
 		} else {
 			$ret .= "<!DOCTYPE html PUBLIC \"$wgDocType\" \"$wgDTD\">\n";
 			$ret .= "<html xmlns=\"{$wgXhtmlDefaultNamespace}\" ";
 			foreach($wgXhtmlNamespaces as $tag => $ns) {
 				$ret .= "xmlns:{$tag}=\"{$ns}\" ";
 			}
-			$ret .= "xml:lang=\"$wgContLanguageCode\" lang=\"$wgContLanguageCode\" dir=\"$dir\">\n";
+			$ret .= "lang=\"$wgContLanguageCode\" dir=\"$dir\">\n";
 		}
 
 		$ret .= "<head>\n";
@@ -1723,23 +2121,102 @@ class OutputPage {
 		$ret .= implode( "\n", array(
 			$this->getHeadLinks(),
 			$this->buildCssLinks(),
-			$sk->getHeadScripts( $this ),
+			$this->getHeadScripts( $sk ),
 			$this->getHeadItems(),
 		));
 		if( $sk->usercss ){
 			$ret .= Html::inlineStyle( $sk->usercss );
 		}
 
-		if( $wgEnableScriptLoader )
-			$ret .= $this->getScriptLoaderJs();
-
 		if ($wgUseTrackbacks && $this->isArticleRelated())
 			$ret .= $this->getTitle()->trackbackRDF();
 
 		$ret .= "</head>\n";
+
+		$bodyAttrs = array();
+
+		# Crazy edit-on-double-click stuff
+		$action = $wgRequest->getVal( 'action', 'view' );
+
+		if ( $this->getTitle()->getNamespace() != NS_SPECIAL
+		&& !in_array( $action, array( 'edit', 'submit' ) )
+		&& $wgUser->getOption( 'editondblclick' ) ) {
+			$bodyAttrs['ondblclick'] = "document.location = '" . Xml::escapeJsString( $this->getTitle()->getEditURL() ) . "'";
+		}
+
+		# Class bloat
+		$bodyAttrs['class'] = "mediawiki $dir";
+
+		if ( $wgLang->capitalizeAllNouns() ) {
+			# A <body> class is probably not the best way to do this . . .
+			$bodyAttrs['class'] .= ' capitalize-all-nouns';
+		}
+		$bodyAttrs['class'] .= ' ns-' . $this->getTitle()->getNamespace();
+		if ( $this->getTitle()->getNamespace() == NS_SPECIAL ) {
+			$bodyAttrs['class'] .= ' ns-special';
+		} elseif ( $this->getTitle()->isTalkPage() ) {
+			$bodyAttrs['class'] .= ' ns-talk';
+		} else {
+			$bodyAttrs['class'] .= ' ns-subject';
+		}
+		$bodyAttrs['class'] .= ' ' . Sanitizer::escapeClass( 'page-' . $this->getTitle()->getPrefixedText() );
+		$bodyAttrs['class'] .= ' skin-' . Sanitizer::escapeClass( $wgUser->getSkin()->getSkinName() );
+
+		$ret .= Html::openElement( 'body', $bodyAttrs ) . "\n";
+
 		return $ret;
 	}
 
+	/**
+	 * Gets the global variables and mScripts; also adds userjs to the end if
+	 * enabled
+	 *
+	 * @param $sk Skin object to use
+	 * @return String: HTML fragment
+	 */
+	function getHeadScripts( Skin $sk ) {
+		global $wgUser, $wgRequest, $wgJsMimeType, $wgUseSiteJs;
+		global $wgStylePath, $wgStyleVersion;
+
+		$scripts = Skin::makeGlobalVariablesScript( $sk->getSkinName() );
+		$scripts .= Html::linkedScript( "{$wgStylePath}/common/wikibits.js?$wgStyleVersion" );
+
+		//add site JS if enabled:
+		if( $wgUseSiteJs ) {
+			$jsCache = $wgUser->isLoggedIn() ? '&smaxage=0' : '';
+			$this->addScriptFile(  Skin::makeUrl( '-',
+					"action=raw$jsCache&gen=js&useskin=" .
+					urlencode( $sk->getSkinName() )
+					)
+				);
+		}
+
+		//add user js if enabled:
+		if( $this->isUserJsAllowed() && $wgUser->isLoggedIn() ) {
+			$action = $wgRequest->getVal( 'action', 'view' );
+			if( $this->mTitle && $this->mTitle->isJsSubpage() and $sk->userCanPreview( $action ) ) {
+				# XXX: additional security check/prompt?
+				$this->addInlineScript( $wgRequest->getText( 'wpTextbox1' ) );
+			} else {
+				$userpage = $wgUser->getUserPage();
+				$scriptpage = Title::makeTitleSafe(
+					NS_USER,
+					$userpage->getDBkey() . '/' . $sk->getSkinName() . '.js'
+				);
+				if ( $scriptpage && $scriptpage->exists() ) {
+					$userjs = Skin::makeUrl( $scriptpage->getPrefixedText(), 'action=raw&ctype=' . $wgJsMimeType );
+					$this->addScriptFile( $userjs );
+				}
+			}
+		}
+
+		$scripts .= "\n" . $this->mScripts;
+		return $scripts;
+	}
+
+	/**
+	 * Add default \<meta\> tags
+	 */
 	protected function addDefaultMeta() {
 		global $wgVersion, $wgHtml5;
 
@@ -1789,13 +2266,13 @@ class OutputPage {
 			} else {
 				$a = 'name';
 			}
-			$tags[] = Xml::element( 'meta',
+			$tags[] = Html::element( 'meta',
 				array(
 					$a => $tag[0],
 					'content' => $tag[1] ) );
 		}
 		foreach ( $this->mLinktags as $tag ) {
-			$tags[] = Xml::element( 'link', $tag );
+			$tags[] = Html::element( 'link', $tag );
 		}
 
 		if( $wgFeed ) {
@@ -1808,7 +2285,8 @@ class OutputPage {
 				$tags[] = $this->feedLink(
 					$format,
 					$link,
-					wfMsg( "page-{$format}-feed", $this->getTitle()->getPrefixedText() ) ); # Used messages: 'page-rss-feed' and 'page-atom-feed' (for an easier grep)
+					# Used messages: 'page-rss-feed' and 'page-atom-feed' (for an easier grep)
+					wfMsg( "page-{$format}-feed", $this->getTitle()->getPrefixedText() ) );
 			}
 
 			# Recent changes feed should appear on every page (except recentchanges,
@@ -1819,7 +2297,7 @@ class OutputPage {
 			# or "Breaking news" one). For this, we see if $wgOverrideSiteFeed is defined.
 			# If so, use it instead.
 
-			global $wgOverrideSiteFeed, $wgSitename, $wgFeedClasses;
+			global $wgOverrideSiteFeed, $wgSitename, $wgAdvertisedFeedTypes;
 			$rctitle = SpecialPage::getTitleFor( 'Recentchanges' );
 
 			if ( $wgOverrideSiteFeed ) {
@@ -1829,9 +2307,8 @@ class OutputPage {
 						htmlspecialchars( $feedUrl ),
 						wfMsg( "site-{$type}-feed", $wgSitename ) );
 				}
-			}
-			else if ( $this->getTitle()->getPrefixedText() != $rctitle->getPrefixedText() ) {
-				foreach( $wgFeedClasses as $format => $class ) {
+			} elseif ( $this->getTitle()->getPrefixedText() != $rctitle->getPrefixedText() ) {
+				foreach ( $wgAdvertisedFeedTypes as $format ) {
 					$tags[] = $this->feedLink(
 						$format,
 						$rctitle->getLocalURL( "feed={$format}" ),
@@ -1840,36 +2317,19 @@ class OutputPage {
 			}
 		}
 
-		return implode( "\n", $tags ) . "\n";
-	}
-
-	/**
-	 * Return URLs for each supported syndication format for this page.
-	 * @return array associating format keys with URLs
-	 */
-	public function getSyndicationLinks() {
-		global $wgFeedClasses;
-		$links = array();
-
-		if( $this->isSyndicated() ) {
-			if( is_string( $this->getFeedAppendQuery() ) ) {
-				$appendQuery = "&" . $this->getFeedAppendQuery();
-			} else {
-				$appendQuery = "";
-			}
-
-			foreach( $wgFeedClasses as $format => $class ) {
-				$links[$format] = $this->getTitle()->getLocalUrl( "feed=$format{$appendQuery}" );
-			}
-		}
-		return $links;
+		return implode( "\n", $tags );
 	}
 
 	/**
-	 * Generate a <link rel/> for an RSS feed.
+	 * Generate a <link rel/> for a feed.
+	 *
+	 * @param $type String: feed type
+	 * @param $url String: URL to the feed
+	 * @param $text String: value of the "title" attribute
+	 * @return String: HTML fragment
 	 */
 	private function feedLink( $type, $url, $text ) {
-		return Xml::element( 'link', array(
+		return Html::element( 'link', array(
 			'rel' => 'alternate',
 			'type' => "application/$type+xml",
 			'title' => $text,
@@ -1880,9 +2340,10 @@ class OutputPage {
 	 * Add a local or specified stylesheet, with the given media options.
 	 * Meant primarily for internal use...
 	 *
-	 * @param $media -- to specify a media type, 'screen', 'printable', 'handheld' or any.
-	 * @param $conditional -- for IE conditional comments, specifying an IE version
-	 * @param $dir -- set to 'rtl' or 'ltr' for direction-specific sheets
+	 * @param $style String: URL to the file
+	 * @param $media String: to specify a media type, 'screen', 'printable', 'handheld' or any.
+	 * @param $condition String: for IE conditional comments, specifying an IE version
+	 * @param $dir String: set to 'rtl' or 'ltr' for direction-specific sheets
 	 */
 	public function addStyle( $style, $media='', $condition='', $dir='' ) {
 		$options = array();
@@ -1920,6 +2381,14 @@ class OutputPage {
 		return implode( "\n", $links );
 	}
 
+	/**
+	 * Generate \<link\> tags for stylesheets
+	 *
+	 * @param $style String: URL to the file
+	 * @param $options Array: option, can contain 'condition', 'dir', 'media'
+	 *                 keys
+	 * @return String: HTML fragment
+	 */
 	protected function styleLink( $style, $options ) {
 		global $wgRequest;
 
@@ -1957,6 +2426,12 @@ class OutputPage {
 		return $link;
 	}
 
+	/**
+	 * Transform "media" attribute based on request parameters
+	 *
+	 * @param $media String: current value of the "media" attribute
+	 * @return String: modified value of the "media" attribute
+	 */
 	function transformCssMedia( $media ) {
 		global $wgRequest, $wgHandheldForIPhone;
 
@@ -1995,7 +2470,6 @@ class OutputPage {
 	 * for when rate limiting has triggered.
 	 */
 	public function rateLimited() {
-
 		$this->setPageTitle(wfMsg('actionthrottled'));
 		$this->setRobotPolicy( 'noindex,follow' );
 		$this->setArticleRelated( false );
@@ -2008,24 +2482,6 @@ class OutputPage {
 		$this->returnToMain( null, $this->getTitle() );
 	}
 
-	/**
-	 * Show an "add new section" link?
-	 *
-	 * @return bool
-	 */
-	public function showNewSectionLink() {
-		return $this->mNewSectionLink;
-	}
-
-	/**
-	* Forcibly hide the new section link?
-	*
-	* @return bool
-	*/
-	public function forceHideNewSectionLink() {
-		return $this->mHideNewSectionLink;
-	}
-
 	/**
 	 * Show a warning about slave lag
 	 *
@@ -2033,16 +2489,16 @@ class OutputPage {
 	 * then the warning is a bit more obvious. If the lag is
 	 * lower than $wgSlaveLagWarning, then no warning is shown.
 	 *
-	 * @param int $lag Slave lag
+	 * @param $lag Integer: slave lag
 	 */
 	public function showLagWarning( $lag ) {
-		global $wgSlaveLagWarning, $wgSlaveLagCritical;
+		global $wgSlaveLagWarning, $wgSlaveLagCritical, $wgLang;
 		if( $lag >= $wgSlaveLagWarning ) {
 			$message = $lag < $wgSlaveLagCritical
 				? 'lag-warn-normal'
 				: 'lag-warn-high';
-			$warning = wfMsgExt( $message, 'parse', $lag );
-			$this->addHTML( "<div class=\"mw-{$message}\">\n{$warning}\n</div>\n" );
+			$wrap = Html::rawElement( 'div', array( 'class' => "mw-{$message}" ), "\n$1\n" );
+			$this->wrapWikiMsg( "$wrap\n", array( $message, $wgLang->formatNum( $lag ) ) );
 		}
 	}
 
@@ -2087,11 +2543,13 @@ class OutputPage {
 	 *
 	 * For example:
 	 *
-	 *    $wgOut->wrapWikiMsg( '<div class="error">$1</div>', 'some-error' );
+	 *    $wgOut->wrapWikiMsg( "<div class='error'>\n$1</div>", 'some-error' );
 	 *
 	 * Is equivalent to:
 	 *
-	 *    $wgOut->addWikiText( '<div class="error">' . wfMsgNoTrans( 'some-error' ) . '</div>' );
+	 *    $wgOut->addWikiText( "<div class='error'>\n" . wfMsgNoTrans( 'some-error' ) . "</div>" );
+	 *
+	 * The newline after opening div is needed in some wikitext. See bug 19226.
 	 */
 	public function wrapWikiMsg( $wrap /*, ...*/ ) {
 		$msgSpecs = func_get_args();
@@ -2115,4 +2573,29 @@ class OutputPage {
 		}
 		$this->addHTML( $this->parse( $s, /*linestart*/true, /*uilang*/true ) );
 	}
+
+	/**
+	 * Include jQuery core. Use this to avoid loading it multiple times
+	 * before we get a usable script loader. 
+	 *
+	 * @param $modules Array: list of jQuery modules which should be loaded
+	 * @return Array: the list of modules which were not loaded.
+	 */
+	public function includeJQuery( $modules = array() ) {
+		global $wgStylePath, $wgStyleVersion, $wgJsMimeType;
+
+		$supportedModules = array( /** TODO: add things here */ );
+		$unsupported = array_diff( $modules, $supportedModules );
+
+		$params = array(
+			'type' => $wgJsMimeType,
+			'src' => "$wgStylePath/common/jquery.min.js?$wgStyleVersion",
+		);
+		if ( !$this->mJQueryDone ) {
+			$this->mJQueryDone = true;
+			$this->mScripts = Html::element( 'script', $params ) . "\n" . $this->mScripts;
+		}
+		return $unsupported;
+	}
+
 }