afebb45eb9
Instead use SkinAfterPortlet to force the language portal to always display. This will work with all Wikimedia deployed skins that use ULS (note the Minerva skin is not impacted but in future can benefit from this change) Depends-On: I438daa79d3d97e2518e6258c3213a805bd1f30e8 Bug: T253178 Change-Id: I2843edde1bb45c70911d5acf2f7dafdff3bac53e
560 lines
16 KiB
PHP
560 lines
16 KiB
PHP
<?php
|
|
/**
|
|
* Hooks for UniversalLanguageSelector extension.
|
|
*
|
|
* Copyright (C) 2012-2018 Alolita Sharma, Amir Aharoni, Arun Ganesh, Brandon
|
|
* Harris, Niklas Laxström, Pau Giner, Santhosh Thottingal, Siebrand Mazeland
|
|
* and other contributors. See CREDITS for a list.
|
|
*
|
|
* UniversalLanguageSelector is dual licensed GPLv2 or later and MIT. You don't
|
|
* have to do anything special to choose one license or the other and you don't
|
|
* have to notify anyone which license you are using. You are free to use
|
|
* UniversalLanguageSelector in commercial projects as long as the copyright
|
|
* header is left intact. See files GPL-LICENSE and MIT-LICENSE for details.
|
|
*
|
|
* @file
|
|
* @ingroup Extensions
|
|
* @license GPL-2.0-or-later
|
|
* @license MIT
|
|
*/
|
|
|
|
use MediaWiki\MediaWikiServices;
|
|
|
|
class UniversalLanguageSelectorHooks {
|
|
|
|
/**
|
|
* Used when extension registration in use which skips the main php file
|
|
*/
|
|
public static function setVersionConstant() {
|
|
global $wgHooks;
|
|
define( 'ULS_VERSION', '2018-10-26' );
|
|
// The SkinAfterPortlet hook was introduced in version >= 1.35.
|
|
// It is the same as BaseTemplateAfterPortlet with the exception of its parameters.
|
|
if ( interface_exists( MediaWiki\Skins\Hook\SkinAfterPortletHook::class ) ) {
|
|
$wgHooks['SkinAfterPortlet'][] = "UniversalLanguageSelectorHooks::onSkinAfterPortlet";
|
|
} else {
|
|
$wgHooks['BaseTemplateAfterPortlet'][] = "UniversalLanguageSelectorHooks::onBaseTemplateAfterPortlet";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Whether ULS user toolbar (language selection and settings) is enabled.
|
|
*
|
|
* @param User $user
|
|
* @return bool
|
|
*/
|
|
private static function isToolbarEnabled( User $user ) {
|
|
global $wgULSEnable, $wgULSEnableAnon;
|
|
|
|
if ( !$wgULSEnable ) {
|
|
return false;
|
|
}
|
|
if ( !$wgULSEnableAnon && $user->isAnon() ) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Whether ULS Compact interlanguage links enabled
|
|
*
|
|
* @param User $user
|
|
* @return bool
|
|
*/
|
|
private static function isCompactLinksEnabled( User $user ) {
|
|
global $wgULSEnable, $wgInterwikiMagic,
|
|
$wgULSCompactLinksEnableAnon,
|
|
$wgHideInterlanguageLinks, $wgULSCompactLanguageLinksBetaFeature;
|
|
|
|
// Whether any user visible features are enabled
|
|
if ( !$wgULSEnable ) {
|
|
return false;
|
|
}
|
|
|
|
if ( $user->isAnon() && $wgULSCompactLinksEnableAnon ) {
|
|
return true;
|
|
}
|
|
|
|
if ( $wgULSCompactLanguageLinksBetaFeature === true &&
|
|
$wgInterwikiMagic === true &&
|
|
$wgHideInterlanguageLinks === false &&
|
|
ExtensionRegistry::getInstance()->isLoaded( 'BetaFeatures' ) &&
|
|
BetaFeatures::isFeatureEnabled( $user, 'uls-compact-links' )
|
|
) {
|
|
// Compact language links is a beta feature in this wiki. Check the user's
|
|
// preference.
|
|
return true;
|
|
}
|
|
|
|
if ( $wgULSCompactLanguageLinksBetaFeature === false ) {
|
|
// Compact language links is a default feature in this wiki.
|
|
// Check user preference
|
|
return $user->getBoolOption( 'compact-language-links' );
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Sets user preference to enable the Compact language links if the
|
|
* user account is new.
|
|
*
|
|
* To be removed once no longer needed.
|
|
* @param User $user
|
|
* @param bool $autoCreate
|
|
*/
|
|
public static function onLocalUserCreated( User $user, $autoCreate ) {
|
|
if ( RequestContext::getMain()->getConfig()->get( 'ULSCompactLinksForNewAccounts' ) ) {
|
|
$user->setOption( 'compact-language-links', 1 );
|
|
$user->saveSettings();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param OutputPage $out
|
|
* @param Skin $skin
|
|
* Hook: BeforePageDisplay
|
|
*/
|
|
public static function addModules( OutputPage $out, $skin ) {
|
|
global $wgULSPosition, $wgULSGeoService;
|
|
|
|
// Soft dependency to Wikibase client. Don't enable CLL if links are managed manually.
|
|
$excludedLinks = $out->getProperty( 'noexternallanglinks' );
|
|
$override = is_array( $excludedLinks ) && in_array( '*', $excludedLinks );
|
|
if ( !$override && self::isCompactLinksEnabled( $out->getUser() ) ) {
|
|
$out->addModules( 'ext.uls.compactlinks' );
|
|
}
|
|
|
|
if ( is_string( $wgULSGeoService ) ) {
|
|
$out->addModules( 'ext.uls.geoclient' );
|
|
}
|
|
|
|
if ( self::isToolbarEnabled( $out->getUser() ) ) {
|
|
// Enable UI language selection for the user.
|
|
$out->addModules( 'ext.uls.interface' );
|
|
}
|
|
|
|
if ( $wgULSPosition === 'personal' ) {
|
|
$out->addModuleStyles( 'ext.uls.pt' );
|
|
} else {
|
|
$out->addModuleStyles( 'ext.uls.interlanguage' );
|
|
}
|
|
|
|
if ( $out->getTitle()->isSpecial( 'Preferences' ) ) {
|
|
$out->addModuleStyles( 'ext.uls.preferencespage' );
|
|
}
|
|
|
|
self::handleSetLang( $out );
|
|
}
|
|
|
|
/**
|
|
* Handle setlang query parameter; and decide if the setlang related scripts
|
|
* have to be loaded.
|
|
* @param OutputPage $out
|
|
* @return void
|
|
*/
|
|
protected static function handleSetLang( OutputPage $out ): void {
|
|
$languageToSet = self::getSetLang( $out );
|
|
|
|
if ( !$languageToSet ) {
|
|
return;
|
|
}
|
|
|
|
MediaWikiServices::getInstance()->getStatsdDataFactory()
|
|
->increment( 'uls.setlang_used' );
|
|
|
|
$user = $out->getUser();
|
|
if ( $user->isAnon() && !$out->getConfig()->get( 'ULSAnonCanChangeLanguage' ) ) {
|
|
// User is anon, and cannot change language, return.
|
|
return;
|
|
}
|
|
|
|
$out->addModules( 'ext.uls.setlang' );
|
|
}
|
|
|
|
/**
|
|
* @param ResourceLoader $resourceLoader
|
|
*/
|
|
public static function onResourceLoaderRegisterModules( ResourceLoader $resourceLoader ) {
|
|
global $wgVersion;
|
|
|
|
// Support: MediaWiki 1.34
|
|
$hasOldNotify = version_compare( $wgVersion, '1.35', '<' );
|
|
|
|
$tpl = [
|
|
'localBasePath' => dirname( __DIR__ ) . '/resources',
|
|
'remoteExtPath' => 'UniversalLanguageSelector/resources',
|
|
];
|
|
|
|
$modules = [
|
|
"ext.uls.ime" => $tpl + [
|
|
"scripts" => "js/ext.uls.ime.js",
|
|
"dependencies" => array_merge( [
|
|
"ext.uls.common",
|
|
"ext.uls.preferences",
|
|
"ext.uls.mediawiki",
|
|
"ext.uls.messages",
|
|
"jquery.ime",
|
|
], $hasOldNotify ? [ 'mediawiki.notify' ] : [] ),
|
|
"messages" => [
|
|
"uls-ime-helppage"
|
|
],
|
|
],
|
|
"ext.uls.setlang" => $tpl + [
|
|
"styles" => [
|
|
"css/ext.uls.dialog.less",
|
|
"css/ext.uls.setlang.less"
|
|
],
|
|
"scripts" => [
|
|
"js/ext.uls.dialog.js",
|
|
"js/ext.uls.setlang.js"
|
|
],
|
|
"dependencies" => array_merge( [
|
|
"mediawiki.api",
|
|
"mediawiki.ui.button",
|
|
"mediawiki.Uri"
|
|
], $hasOldNotify ? [ 'mediawiki.notify' ] : [] ),
|
|
"messages" => [
|
|
"ext-uls-setlang-error",
|
|
"ext-uls-setlang-unknown-error",
|
|
"ext-uls-setlang-heading",
|
|
"ext-uls-setlang-message",
|
|
"ext-uls-setlang-accept",
|
|
"ext-uls-setlang-cancel",
|
|
"ext-uls-setlang-loading"
|
|
],
|
|
],
|
|
];
|
|
|
|
$resourceLoader->register( $modules );
|
|
}
|
|
|
|
/**
|
|
* Add some tabs for navigation for users who do not use Ajax interface.
|
|
* Hook: PersonalUrls
|
|
* @param array &$personal_urls
|
|
* @param Title &$title
|
|
* @param SkinTemplate $context SkinTemplate object providing context
|
|
*/
|
|
public static function addPersonalBarTrigger(
|
|
array &$personal_urls,
|
|
&$title,
|
|
SkinTemplate $context
|
|
) {
|
|
global $wgULSPosition;
|
|
|
|
if ( $wgULSPosition !== 'personal' ) {
|
|
return;
|
|
}
|
|
|
|
if ( !self::isToolbarEnabled( $context->getUser() ) ) {
|
|
return;
|
|
}
|
|
|
|
// The element id will be 'pt-uls'
|
|
$langCode = $context->getLanguage()->getCode();
|
|
$personal_urls = [
|
|
'uls' => [
|
|
'text' => Language::fetchLanguageName( $langCode ),
|
|
'href' => '#',
|
|
'class' => 'uls-trigger',
|
|
'active' => true
|
|
]
|
|
] + $personal_urls;
|
|
}
|
|
|
|
/**
|
|
* @param array $preferred
|
|
* @return string
|
|
*/
|
|
protected static function getDefaultLanguage( array $preferred ) {
|
|
$supported = Language::fetchLanguageNames( null, 'mwfile' );
|
|
|
|
// look for a language that is acceptable to the client
|
|
// and known to the wiki.
|
|
foreach ( $preferred as $code => $weight ) {
|
|
if ( isset( $supported[$code] ) ) {
|
|
return $code;
|
|
}
|
|
}
|
|
|
|
// Some browsers might only send codes like de-de.
|
|
// Try with bare code.
|
|
foreach ( $preferred as $code => $weight ) {
|
|
$parts = explode( '-', $code, 2 );
|
|
$code = $parts[0];
|
|
if ( isset( $supported[$code] ) ) {
|
|
return $code;
|
|
}
|
|
}
|
|
|
|
return '';
|
|
}
|
|
|
|
/**
|
|
* Hook to UserGetLanguageObject
|
|
* @param User $user
|
|
* @param string &$code
|
|
* @param IContextSource $context
|
|
*/
|
|
public static function getLanguage( User $user, &$code, IContextSource $context ) {
|
|
global $wgULSAnonCanChangeLanguage, $wgULSLanguageDetection;
|
|
|
|
if ( $wgULSLanguageDetection ) {
|
|
// Vary any caching based on the header value. Note that
|
|
// we need to vary regardless of whether we end up using
|
|
// the header or not, so that requests without the header
|
|
// don't show up for people with it.
|
|
$context->getOutput()->addVaryHeader( 'Accept-Language' );
|
|
}
|
|
|
|
if ( !self::isToolbarEnabled( $user ) ) {
|
|
return;
|
|
}
|
|
|
|
$request = $context->getRequest();
|
|
|
|
if (
|
|
// uselang can be used for temporary override of language preference
|
|
$request->getText( 'uselang' ) ||
|
|
// Registered user: use preferences
|
|
!$user->isAnon()
|
|
) {
|
|
return;
|
|
}
|
|
|
|
// If using cookie storage for anons is OK, read from that
|
|
if ( $wgULSAnonCanChangeLanguage ) {
|
|
// Try to set the language based on the cookie
|
|
$languageToUse = $request->getCookie( 'language', null, '' );
|
|
if ( Language::isSupportedLanguage( $languageToUse ) ) {
|
|
$code = $languageToUse;
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
// As last resort, try Accept-Language headers if allowed
|
|
if ( $wgULSLanguageDetection ) {
|
|
// We added a Vary header at the top of this function,
|
|
// since we're depending upon the Accept-Language header
|
|
$preferred = $request->getAcceptLang();
|
|
$default = self::getDefaultLanguage( $preferred );
|
|
if ( $default !== '' ) {
|
|
$code = $default;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Hook: ResourceLoaderGetConfigVars
|
|
* @param array &$vars
|
|
*/
|
|
public static function addConfig( array &$vars ) {
|
|
global $wgULSGeoService,
|
|
$wgULSIMEEnabled, $wgULSWebfontsEnabled,
|
|
$wgULSPosition, $wgULSNoWebfontsSelectors,
|
|
$wgULSAnonCanChangeLanguage,
|
|
$wgULSEventLogging,
|
|
$wgULSImeSelectors, $wgULSNoImeSelectors,
|
|
$wgULSFontRepositoryBasePath,
|
|
$wgExtensionAssetsPath,
|
|
$wgInterwikiSortingSortPrepend;
|
|
|
|
// Place constant stuff here (not depending on request context)
|
|
|
|
if ( is_string( $wgULSGeoService ) ) {
|
|
$vars['wgULSGeoService'] = $wgULSGeoService;
|
|
}
|
|
|
|
$vars['wgULSIMEEnabled'] = $wgULSIMEEnabled;
|
|
$vars['wgULSWebfontsEnabled'] = $wgULSWebfontsEnabled;
|
|
$vars['wgULSPosition'] = $wgULSPosition;
|
|
$vars['wgULSAnonCanChangeLanguage'] = $wgULSAnonCanChangeLanguage;
|
|
$vars['wgULSEventLogging'] = $wgULSEventLogging
|
|
&& ExtensionRegistry::getInstance()->isLoaded( 'EventLogging' );
|
|
$vars['wgULSImeSelectors'] = $wgULSImeSelectors;
|
|
$vars['wgULSNoImeSelectors'] = $wgULSNoImeSelectors;
|
|
$vars['wgULSNoWebfontsSelectors'] = $wgULSNoWebfontsSelectors;
|
|
|
|
if ( is_string( $wgULSFontRepositoryBasePath ) ) {
|
|
$vars['wgULSFontRepositoryBasePath'] = $wgULSFontRepositoryBasePath;
|
|
} else {
|
|
$vars['wgULSFontRepositoryBasePath'] = $wgExtensionAssetsPath .
|
|
'/UniversalLanguageSelector/data/fontrepo/fonts/';
|
|
}
|
|
|
|
if ( isset( $wgInterwikiSortingSortPrepend ) && $wgInterwikiSortingSortPrepend !== [] ) {
|
|
$vars['wgULSCompactLinksPrepend'] = $wgInterwikiSortingSortPrepend;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Hook: MakeGlobalVariablesScript
|
|
* @param array &$vars
|
|
* @param OutputPage $out
|
|
*/
|
|
public static function addVariables( array &$vars, OutputPage $out ) {
|
|
// Place request context dependent stuff here
|
|
$user = $out->getUser();
|
|
$loggedIn = $user->isLoggedIn();
|
|
|
|
// Do not output accept languages if there is risk it will get cached across requests
|
|
if ( $out->getConfig()->get( 'ULSAnonCanChangeLanguage' ) || $loggedIn ) {
|
|
$vars['wgULSAcceptLanguageList'] = array_keys( $out->getRequest()->getAcceptLang() );
|
|
}
|
|
|
|
if ( $loggedIn && class_exists( Babel::class ) ) {
|
|
$userLanguageInfo = Babel::getCachedUserLanguageInfo( $user );
|
|
|
|
// This relies on the fact that Babel levels are 'N' and
|
|
// the digits 0 to 5 as strings, and that in reverse
|
|
// ASCII order they will be 'N', '5', '4', '3', '2', '1', '0'.
|
|
arsort( $userLanguageInfo );
|
|
|
|
$vars['wgULSBabelLanguages'] = array_keys( $userLanguageInfo );
|
|
}
|
|
|
|
// An optimization to avoid loading all of uls.data just to get the autonym
|
|
$langCode = $out->getLanguage()->getCode();
|
|
$vars['wgULSCurrentAutonym'] = Language::fetchLanguageName( $langCode );
|
|
|
|
$setLangCode = self::getSetLang( $out );
|
|
if ( $setLangCode ) {
|
|
$vars['wgULSCurrentLangCode'] = $langCode;
|
|
$vars['wgULSSetLangCode'] = $setLangCode;
|
|
$vars['wgULSSetLangName'] = Language::fetchLanguageName( $setLangCode );
|
|
}
|
|
}
|
|
|
|
public static function onGetPreferences( $user, array &$preferences ) {
|
|
global $wgULSCompactLanguageLinksBetaFeature;
|
|
|
|
$preferences['uls-preferences'] = [
|
|
'type' => 'api',
|
|
];
|
|
|
|
// A link shown for accessing ULS language settings from preferences screen
|
|
$preferences['languagesettings'] = [
|
|
'type' => 'info',
|
|
'raw' => true,
|
|
'section' => 'personal/i18n',
|
|
// We use this class to hide this from no-JS users
|
|
'cssclass' => 'uls-preferences-link-wrapper',
|
|
'default' => "<a id='uls-preferences-link' role='button' tabindex='0'>" .
|
|
wfMessage( 'ext-uls-language-settings-preferences-link' )->escaped() . "</a>",
|
|
];
|
|
|
|
if ( $wgULSCompactLanguageLinksBetaFeature === false ) {
|
|
$preferences['compact-language-links'] = [
|
|
'type' => 'check',
|
|
'section' => 'rendering/languages',
|
|
'label-message' => [
|
|
'ext-uls-compact-language-links-preference',
|
|
'mediawikiwiki:Special:MyLanguage/Universal_Language_Selector/Compact_Language_Links'
|
|
]
|
|
];
|
|
}
|
|
}
|
|
|
|
public static function onGetBetaFeaturePreferences( $user, array &$prefs ) {
|
|
global $wgExtensionAssetsPath, $wgULSCompactLanguageLinksBetaFeature,
|
|
$wgHideInterlanguageLinks, $wgInterwikiMagic;
|
|
|
|
if ( $wgULSCompactLanguageLinksBetaFeature === true &&
|
|
$wgInterwikiMagic === true &&
|
|
$wgHideInterlanguageLinks === false
|
|
) {
|
|
$imagesDir = "$wgExtensionAssetsPath/UniversalLanguageSelector/resources/images";
|
|
$prefs['uls-compact-links'] = [
|
|
'label-message' => 'uls-betafeature-label',
|
|
'desc-message' => 'uls-betafeature-desc',
|
|
'screenshot' => [
|
|
'ltr' => "$imagesDir/compact-links-ltr.svg",
|
|
'rtl' => "$imagesDir/compact-links-rtl.svg",
|
|
],
|
|
'info-link' =>
|
|
'https://www.mediawiki.org/wiki/Special:MyLanguage/' .
|
|
'Universal_Language_Selector/Compact_Language_Links',
|
|
'discussion-link' =>
|
|
'https://www.mediawiki.org/wiki/Talk:Universal_Language_Selector/Compact_Language_Links',
|
|
];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param QuickTemplate $template
|
|
* @param string $name
|
|
* @param string &$content
|
|
*/
|
|
public static function onBaseTemplateAfterPortlet(
|
|
QuickTemplate $template,
|
|
string $name,
|
|
string &$content
|
|
) {
|
|
self::onSkinAfterPortlet( $template->getSkin(), $name, $content );
|
|
}
|
|
|
|
/**
|
|
* @param Skin $skin
|
|
* @param string $name
|
|
* @param string &$content
|
|
*/
|
|
public static function onSkinAfterPortlet(
|
|
Skin $skin,
|
|
string $name,
|
|
string &$content
|
|
) {
|
|
global $wgULSPosition;
|
|
|
|
if ( $name !== 'lang' ) {
|
|
return;
|
|
}
|
|
|
|
if ( $wgULSPosition !== 'interlanguage' ) {
|
|
return;
|
|
}
|
|
|
|
if ( !self::isToolbarEnabled( $skin->getUser() ) ) {
|
|
return;
|
|
}
|
|
|
|
// An empty span will force the language portal to always display in
|
|
// the skins that support it! e.g. Vector.
|
|
if ( count( $skin->getLanguages() ) === 0 ) {
|
|
// If no languages force it on.
|
|
$content .= Html::element(
|
|
'span',
|
|
[
|
|
'class' => 'uls-after-portlet-link',
|
|
],
|
|
''
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add basic webfonts support to the mobile interface (via MobileFrontend extension)
|
|
* Hook: EnterMobileMode
|
|
* @param MobileContext $context
|
|
*/
|
|
public static function onEnterMobileMode( MobileContext $context ) {
|
|
global $wgULSEnable, $wgULSMobileWebfontsEnabled;
|
|
|
|
// Currently only supported in mobile Beta mode
|
|
if ( $wgULSEnable && $wgULSMobileWebfontsEnabled && $context->isBetaGroupMember() ) {
|
|
$context->getOutput()->addModules( 'ext.uls.webfonts.mobile' );
|
|
}
|
|
}
|
|
|
|
private static function getSetLang( OutputPage $out ): ?string {
|
|
$setLangCode = $out->getRequest()->getText( 'setlang' );
|
|
if ( $setLangCode && Language::isSupportedLanguage( $setLangCode ) ) {
|
|
return $setLangCode;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|