MediaWiki:Gadget-HotCat.js: Difference between revisions

 

 

 

 

 

 

 

*/

( function ( $, mw ) {

// Don't use mw.config.get() as that takes a copy of the config, and so doesn't

// account for values changing, e.g. wgCurRevisionId after a VE edit

 

return;

 

// Configuration stuff.

messages: {

cat_removed: 'removed [[Category:$1]]',

// see localization hook below.

multi_error: 'Could not retrieve the page text from the server. Therefore, your category changes ' +

// Defaults to '[[' + category_canonical + ':$1]]'. Can be overridden if in the short edit summaries

// not the standard category name should be used but, say, a shorter namespace alias. $1 is replaced

// The little modification links displayed after category names. U+2212 is a minus sign; U+2193 and U+2191 are

// downward and upward pointing arrows. Do not use ↓ and ↑ in the code!

// The tooltips for the above links

tooltips: {

return (

ns < 0 || // Special pages; Special:Upload is handled differently

},

// A regexp matching a templates used to mark uncategorized pages, if your wiki does have that.

// If not, set it to null.

// The images used for the little indication icon. Should not need changing.

existsYes: '//upload.wikimedia.org/wikipedia/commons/thumb/b/be/P_yes.svg/20px-P_yes.svg.png',

parentcat: 'Parent categories'

},

// If upload_disabled is true, HotCat will not be used on the Upload form.

upload_disabled: false,

// Stuff changeable by users:

// Background for changed categories in multi-edit mode. Default is a very light salmon pink.

// If true, HotCat will never automatically submit changes. HotCat will only open an edit page with

// the changes; users must always save explicitly.

use_up_down: true,

// Default list size

// If true, single category changes are marked as minor edits. If false, they're not.

single_minor: true,

shortcuts: null,

addShortcuts: function ( map ) {

window.HotCat.shortcuts = window.HotCat.shortcuts || {};

for ( var k in map ) {

var v = map[ k ];

k = k.replace( /^\s+|\s+$/g, '' );

v = v.replace( /^\s+|\s+$/g, '' );

window.HotCat.shortcuts[ k ] = v;

}

var ua = navigator.userAgent.toLowerCase();

var is_webkit = /applewebkit\/\d+/.test( ua ) && ua.indexOf( 'spoofer' ) < 0;

 

}

};

}

 

var loadTrigger = new LoadTrigger( 2 );

 

var s = document.createElement( 'script' );

 

}

};

}

 

}

 

var url = href;

}

 

// Load local configurations, overriding the pre-set default values in the HotCat object above. This is always loaded

// be used to change the default settings, or to provide localized interface texts for edit summaries and so on.

 

// Load localized UI texts. These are the texts that HotCat displays on the page itself. Texts shown in edit summaries

if ( conf.wgUserLanguage !== 'en' ) {

// Lupo: somebody thought it would be a good idea to add this. So the default is true, and you have to set it to false

// Localization hook to localize HotCat messages, tooltips, and engine names for wgUserLanguage.

if ( window.hotcat_translations_from_commons && conf.wgServer.indexOf( '//commons' ) < 0 ) {

loadURI( '//commons.wikimedia.org/w/index.php?title=' +

} else {

// Load translations locally

}

} else {

var namespaceIds = conf.wgNamespaceIds;

function autoLocalize( namespaceNumber, fallback ) {

var regex_name = '';

for ( var i = 0; i < name.length; i++ ) {

}

return regex_name

fallback = fallback.toLowerCase();

var canonical = formattedNamespaces[ String( namespaceNumber ) ].toLowerCase();

if ( namespaceIds ) {

for ( var cat_name in namespaceIds ) {

namespaceIds[ cat_name ] === namespaceNumber

) {

}

}

}

 

 

// Utility functions. Yes, this duplicates some functionality that also exists in other places, but

// these few operations here.

function make( arg, literal ) {

return literal ? document.createTextNode( arg ) : document.createElement( arg );

}

function param( name, uri ) {

var re = new RegExp( '[&?]' + name + '=([^&#]*)' );

var m = re.exec( uri );

return null;

}

function title( href ) {

var script = conf.wgScript + '?';

if ( href.indexOf( script ) === 0 || href.indexOf( conf.wgServer + script ) === 0 || conf.wgServer.substring( 0, 2 ) === '//' && href.indexOf( document.location.protocol + conf.wgServer + script ) === 0 ) {

// href="/wiki/..."

var prefix = conf.wgArticlePath.replace( '$1', '' );

}

return null;

}

function capitalize( str ) {

return str.substr( 0, 1 ).toUpperCase() + str.substr( 1 );

}

// Replace $1, $2, or ${key1}, ${key2}, or $key1, $key2 by values from map. $$ is replaced by a single $.

return function ( str, map ) {

return str.replace( re, function ( match, prefix, idx, key, alpha ) {

var k = alpha || key || idx;

var replacement = typeof map[ k ] === 'function' ? map[ k ]( match, k ) : map[ k ];

var substitute = substituteFactory();

var replaceShortcuts = ( function () {

return function ( str, map ) {

var s = replaceHash( str, map );

};

}() );

 

var findCatsRE =

 

function replaceByBlanks( match ) {

function find_category( wikitext, category, once ) {

var cat_regex = null;

cat_regex = new RegExp(

wikiTextBlankOrBidi + '(\\|.*?)?\\}\\}',

'g'

var initial = cat_name.substr( 0, 1 );

cat_regex = new RegExp(

initial :

cat_name.substring( 1 ).replace( wikiTextBlankRE, wikiTextBlank ) +

wikiTextBlankOrBidi + '(\\|.*?)?\\]\\]',

);

}

var copiedtext = wikitext

.replace( /<!--(\s|\S)*?-->/g, replaceByBlanks )

var curr_match = null;

while ( ( curr_match = cat_regex.exec( copiedtext ) ) !== null ) {

}

result.re = cat_regex;

var index = -1;

findCatsRE.lastIndex = 0;

if ( index < 0 ) {

// Find the index of the first interlanguage link...

var match = null;

if ( !interlanguageRE ) {

match = /((^|\n\r?)(\[\[\s*(([a-z]{2,3}(-[a-z]+)*)|simple|tokipona)\s*:[^\]]+\]\]\s*))+$/.exec( copiedtext );

} else {

match = interlanguageRE.exec( copiedtext );

}

}

}

 

matches = find_category( wikitext, toRemove );

} else {

if ( matches.length > 1 ) {

matches.re.lastIndex = 0;

after = after.replace( matches.re, '' );

}

if ( toAdd ) {

}

// Remove whitespace (properly): strip whitespace, but only up to the next line feed.

// whitespace characters, insert a blank.

var i = before.length - 1;

var j = 0;

if (

before += ' ';

}

cat_point = before.length;

wikitext = before + after;

if ( !keyChange ) {

}

}

}

matches = find_category( wikitext, toAdd );

} else {

var onCat = false;

var suffix = wikitext.substring( cat_point );

wikitext = wikitext.substring( 0, cat_point ) + ( cat_point > 0 ? '\n' : '' ) + newcatstring + ( !onCat ? '\n' : '' );

} else {

}

if ( keyChange ) {

var k = key || '';

} else {

}

if ( txt.length !== wikitext.length ) {

wikitext = txt;

}

}

}

}

}

 

function evtKeys( e ) {

/* eslint-disable no-bitwise */

var code = 0;

}

return code;

}

function evtKill( e ) {

e.preventDefault();

e.stopPropagation();

}

 

 

 

 

 

 

}

 

}

}

}

 

var saveInProgress = false;

function initiateEdit( doEdit, failure ) {

saveInProgress = true;

var oldButtonState;

function fail() {

saveInProgress = false;

failure.apply( this, arguments );

}

 

// Must use Ajax here to get the user options and the edit token.

setPage( json );

doEdit( fail );

}

} );

}

 

function multiChangeMsg( count ) {

return substitute( msg, [ null, String( count ) ] );

}

 

function performChanges( failure, singleEditor ) {

if ( pageText === null ) {

return;

}

// Backwards compatibility after message change (added $2 to cat_keychange)

// More backwards-compatibility with earlier HotCat versions:

// Create a form and submit it. We don't use the edit API (api.php?action=edit) because

// (a) sensibly reporting back errors like edit conflicts is always a hassle, and

// current user, then we set the "oldid" value and switch to diff, which gives the "you are editing an old version;

// if you save, any more recent changes will be lost" screen.

// If we do have an edit conflict, but not with ourself, that's no reason not to attempt to save: the server side may actually be able to

// merge the changes. We just need to make sure that we do present a diff view if it's a self edit conflict.

commitForm.wpEditToken.value = editToken;

action = commitForm.wpDiff;

} else {

action = commitForm.wpSave;

}

for ( i = 0; i < toEdit.length; i++ ) {

result = change_category(

result.text,

if ( !result.error ) {

changes++;

} else {

}

} else if ( error === null ) {

}

} else if (

if ( !result.error ) {

changes++;

} else if ( error === null ) {

error = result.error;

if ( error !== null ) { // Do not commit if there were errors

action = commitForm.wpSave;

}

// Fill in the form and submit it

commitForm.wpMinoredit.checked = minorEdits;

}

var summary = [];

var shortSummary = [];

// Deleted

// Added

// Changed

var arrow = is_rtl ? '\u2190' : '\u2192'; // left and right arrows. Don't use ← and → in the code.

for ( i = 0; i < changed.length; i++ ) {

if ( changed[ i ].from !== changed[ i ].to ) {

} else {

}

}

if ( changed.length === 1 ) {

if ( changed[ 0 ].from !== changed[ 0 ].to ) {

} else {

}

shortSummary.push( '± ' + multiChangeMsg( changed.length ) );

}

}

}

}

commitForm.wpTextbox1.value = result.text;

commitForm.wpStarttime.value = serverTime || currentTimestamp();

commitForm.wpEdittime.value = pageTime || commitForm.wpStarttime.value;

// Submit the form in a way that triggers onsubmit events: commitForm.submit() doesn't.

commitForm.hcCommit.click();

}

 

function resolveOne( page, toResolve ) {

for ( i = 0; i < toResolve.length; i++ ) {

// Note: the server returns in page an NFC normalized Unicode title. If our input was not NFC normalized, we may not find

// any entry here. If we have only one editor to resolve (the most common case, I presume), we may simply skip the check.

toResolve[ i ].currentHidden = is_hidden;

toResolve[ i ].inputExists = !is_missing;

}

for ( var c = 0; c < cats.length; c++ ) {

var cat = cats[ c ].title;

if ( cat ) {

cat = cat.substring( cat.indexOf( ':' ) + 1 ).replace( /_/g, ' ' );

}

}

}

}

var titles = [];

for ( i = 0; i < lks.length; i++ ) {

lks[ i ].ns === 14 &&

// Name not empty

) {

// Internal link to existing thingy. Extract the page name and remove the namespace.

match = match.substring( match.indexOf( ':' ) + 1 );

// Exclude blacklisted categories.

}

}

for ( i = 0; i < toResolve.length; i++ ) {

toResolve[ i ].inputExists = true; // Might actually be wrong if it's a redirect pointing to a non-existing category

if ( titles.length > 1 ) {

toResolve[ i ].dab = titles;

 

function resolveRedirects( toResolve, params ) {

}

 

}

}

return;

}

} else {

if ( resolved[ i ].dab ) {

} else {

}

}

showDab( firstDab );

} else if ( !dontChange ) {

}

} );

}

 

var suggestionEngines = {

opensearch: {

var titles = queryResult[ 1 ];

var exists = false;

for ( var i = 0; i < titles.length; i++ ) {

cat_prefix.lastIndex = 0;

if ( m && m.length > 1 ) {

titles[ i ] = titles[ i ].substring( titles[ i ].indexOf( ':' ) + 1 ); // rm namespace

} else {

titles.splice( i, 1 ); // Nope, it's not a category after all.

}

titles.exists = exists;

return titles;

}

if ( queryResult && queryResult.query && queryResult.query.allpages ) {

var titles = queryResult.query.allpages;

return titles;

}

var titles = [ title ];

titles.exists = true;

return titles;

}

if ( queryResult && queryResult.query && queryResult.query.categorymembers ) {

var titles = queryResult.query.categorymembers;

return titles;

}

if ( queryResult.query.pages[ p ].categories ) {

var titles = queryResult.query.pages[ p ].categories;

return titles;

}

 

var suggestionConfigs = {

};

 

CategoryEditor.UNCHANGED = 0;

CategoryEditor.OPEN = 1; // Open, but no input yet

CategoryEditor.DELETED = 4;

 

// IE6 sometimes forgets to redraw the list when editors are opened or closed.

// Adding/removing a dummy element helps, at least when opening editors.

 

function forceRedraw() {

}

 

// Event keyCodes that we handle in the text input field/suggestion list.

 

CategoryEditor.prototype = {

after.parentNode.insertBefore( span, after.nextSibling );

after = after.nextSibling;

line.appendChild( span );

}

span.appendChild( make( ' ', true ) );

line.appendChild( span );

this.linkSpan = make( 'span' );

this.linkSpan.className = 'noprint nopopups hotcatlink';

this.linkSpan.appendChild( lk );

span = make( newDOM ? 'li' : 'span' );

span.className = 'noprint';

span.appendChild( this.linkSpan );

if ( after ) {

after.parentNode.insertBefore( span, after.nextSibling );

line.appendChild( span );

}

this.normalLinks = null;

this.undelLink = null;

this.catLink = null;

} else {

this.isAddCategory = false;

this.catLink = span.firstChild;

// Create change and del links

this.makeLinkSpan();

span.appendChild( this.linkSpan );

}

this.originalHidden = is_hidden;

this.line = line;

this.span = span;

this.currentCategory = this.originalCategory;

this.lastSavedExists = this.originalExists;

this.lastSavedHidden = this.originalHidden;

editors[ editors.length ] = this;

},

this.normalLinks = make( 'span' );

var lk = null;

this.normalLinks.appendChild( make( ' ', true ) );

this.normalLinks.appendChild( lk );

}

this.normalLinks.appendChild( make( ' ', true ) );

this.normalLinks.appendChild( lk );

this.upDownLinks = make( 'span' );

this.upDownLinks.appendChild( make( ' ', true ) );

this.upDownLinks.appendChild( lk );

this.upDownLinks.appendChild( make( ' ', true ) );

this.upDownLinks.appendChild( lk );

this.undelLink.className = 'nopopups hotcatlink';

this.undelLink.style.display = 'none';

this.undelLink.appendChild( make( ' ', true ) );

this.undelLink.appendChild( lk );

 

invokeSuggestions: function ( dont_autocomplete ) {

this.state = CategoryEditor.CHANGE_PENDING;

var self = this;

},

 

makeForm: function () {

var form = make( 'form' );

this.form = form;

var self = this;

if ( !noSuggestions ) {

// Be careful here to handle IME input. This is browser/OS/IME dependent, but basically there are two mechanisms:

// - Older browsers signal composition by keyDown === IME for the first and subsequent keys for a composition. The

// first keyDown !== IME is certainly after the end of the composition. Typically, composition end can also be

}

}

// And handle continued pressing of arrow keys

// On IE, blur events are asynchronous, and may thus arrive after the element has lost the focus. Since IE

// can get the selection only while the element is active (has the focus), we may not always get the selection.

// Therefore, use an IE-specific synchronous event on IE...

$( text ).on(

// DOM Level 3 IME handling

try {

// Setting lastKey = IME provides a fake keyDown for Gecko's single keyUp after a cmposition. If we didn't do this,

// cancelling a composition via ESC would also cancel and close the whole category input editor.

} catch ( any ) {

// Just in case some browsers might produce exceptions with these DOM Level 3 events

}

}

this.text = text;

if ( !noSuggestions ) {

list = make( 'select' );

list.onkeyup = function ( evt ) {

if ( evt.keyCode === ESC ) {

self.resetKeySelection();

self.text.focus();

} else if ( evt.keyCode === RET ) {

self.accept( evt );

}

};

var engineSelector = make( 'select' );

for ( var key in suggestionConfigs ) {

var opt = make( 'option' );

opt.value = key;

opt.appendChild( make( suggestionConfigs[ key ].name, true ) );

engineSelector.appendChild( opt );

if (

onUpload &&

) {

try {

label = UFUI.getLabel( id, true );

// Extract the plain text. IE doesn't know that Node.TEXT_NODE === 3

} catch ( ex ) {

label = null;

}

}

return label.data;

}

 

// Do not use type 'submit'; we cannot detect modifier keys if we do

OK.onclick = this.accept.bind( this );

this.ok = OK;

 

cancel.onclick = this.cancel.bind( this );

this.cancelButton = cancel;

span.className = 'hotcatinput';

span.style.position = 'relative';

span.appendChild( text );

 

// then the engine selector may overlap the input field.

span.appendChild( make( '\xa0', true ) );

span.style.whiteSpace = 'nowrap';

 

span.appendChild( OK );

span.appendChild( cancel );

 

display: function ( evt ) {

// eslint-disable-next-line no-new

new CategoryEditor( this.line, null, this.span, true ); // Create a new one

}

}

this.currentCategory = this.lastSavedCategory;

this.currentExists = this.lastSavedExists;

this.currentHidden = this.lastSavedHidden;

this.currentKey = this.lastSavedKey;

this.text.value = this.currentCategory + ( this.currentKey !== null ? '|' + this.currentKey : '' );

this.originalState = this.state;

this.inputExists = this.currentExists;

this.state = this.state === CategoryEditor.UNCHANGED ? CategoryEditor.OPEN : CategoryEditor.CHANGE_PENDING;

this.showsList = false;

// Display the form

this.linkSpan.style.display = 'none';

this.form.style.display = 'inline';

var result = this.display( evt );

var v = this.lastSavedCategory;

this.text.readOnly = !!readOnly;

this.engine = engine;

 

open: function ( evt ) {

},

 

this.inactivate();

this.form.style.display = 'none';

this.linkSpan.style.display = '';

this.state = this.originalState;

this.currentExists = this.lastSavedExists;

this.currentHidden = this.lastSavedHidden;

if ( this.state === CategoryEditor.UNCHANGED ) {

} else {

if ( !onUpload ) {

try {

} catch ( ex ) {}

}

if ( !newDOM ) {

var next = this.span.nextSibling;

}

for ( var i = 0; i < editors.length; i++ ) {

if ( editors[ i ] === this ) {

}

checkMultiInput();

},

 

this.lastSavedHidden = this.originalHidden;

this.state = CategoryEditor.UNCHANGED;

// It was a newly added category. Remove the whole editor.

this.removeEditor();

this.catLink.removeChild( this.catLink.firstChild );

this.catLink.appendChild( make( this.currentCategory, true ) );

this.catLink.title = this.currentKey || '';

this.catLink.className = this.currentExists ? '' : 'new';

this.catLink.style.backgroundColor = 'transparent';

checkMultiInput();

}

 

inactivate: function () {

this.is_active = false;

},

var value = this.text.value.split( '|' );

var key = null;

var v = value[ 0 ].replace( /_/g, ' ' ).replace( /^\s+|\s+$/g, '' );

this.lastInput = v;

this.cancel();

return false;

}

this.cancel();

return false;

resolved[ 0 ].commit(

( resolved[ 0 ].currentCategory !== original ) ?

}

}

this.catLink.removeChild( this.catLink.firstChild );

this.catLink.appendChild( make( this.currentCategory, true ) );

this.catLink.className = this.currentExists ? '' : 'new';

this.lastSavedCategory = this.currentCategory;

this.catLink.style.display = '';

if ( this.isAddCategory ) {

// eslint-disable-next-line no-new

new CategoryEditor( this.line, null, this.span, true ); // Create a new one

// Append an undo link.

var span = make( 'span' );

span.appendChild( make( ' ', true ) );

span.appendChild( lk );

if ( !onUpload ) {

try {

} catch ( ex ) {}

}

}

this.linkSpan.style.display = '';

this.state = CategoryEditor.CHANGED;

(

this.currentKey === this.originalKey ||

)

) ||

conf.wgNamespaceNumber === 14 && this.currentCategory === conf.wgTitle ||

) {

this.cancel();

return;

}

var self = this;

}

},

this.catLink.style.cssText += '; text-decoration : line-through !important;';

try {

} catch ( ex ) {}

this.originalState = this.state;

this.originalState = this.state;

this.state = CategoryEditor.DELETED;

var self = this;

initiateEdit(

}

}

} else {

try {

} catch ( ex ) {}

}

 

selectEngine: function ( engineName ) {

},

 

var v = this.text.value || '';

v = v.replace( /^(\s|_)+/, '' ); // Trim leading blanks and underscores

},

 

makeCall: function ( url, callbackObj, engine, queryKey, cleanKey ) {

 

function done() {

cb.callsMade++;

if ( cb.callsMade === cb.nofCalls ) {

thisObj.text.readOnly = false;

}

}

 

}

} );

},

this.currentKey = null;

}

this.lastInput = v;

this.lastRealInput = v;

 

// Mark blacklisted inputs.

 

if ( noSuggestions ) {

return;

}

 

var cleanKey = v.replace( /[\u200E\u200F\u202A-\u202E]/g, '' ).replace( wikiTextBlankRE, ' ' );

cleanKey = cleanKey.replace( /^\s+|\s+$/g, '' );

 

var engineName = suggestionConfigs[ this.engine ] ? this.engine : 'combined';

 

 

var engines = suggestionConfigs[ engineName ].engines;

this.makeCalls( engines, this.callbackObj, v, cleanKey );

},

this.dab = null;

this.showsList = false;

if ( noSuggestions ) {

this.inputExists = true; // Default...

return;

this.engineName = engineName;

if ( engineName ) {

} else {

}

if ( queryKey ) {

}

this.lastQuery = queryKey;

var v = this.text.value.split( '|' );

var key = v.length > 1 ? '|' + v[ 1 ] : '';

var vNormalized = v;

var knownToExist = titles && titles.exists;

if ( titles ) {

if ( titles.normalized && v.indexOf( queryKey ) === 0 ) {

vNormalized = titles.normalized + v.substring( queryKey.length );

}

var vLow = vNormalized.toLowerCase();

// Strip blacklisted categories

for ( i = 0; i < titles.length; i++ ) {

titles.splice( i, 1 );

i--;

titles.sort(

function ( a, b ) {

// Opensearch may return stuff not beginning with the search prefix!

var prefixMatchA = ( a.indexOf( vNormalized ) === 0 ? 1 : 0 );

var prefixMatchB = ( b.indexOf( vNormalized ) === 0 ? 1 : 0 );

// Case-insensitive prefix match!

prefixMatchA = ( aLow.indexOf( vLow ) === 0 ? 1 : 0 );

prefixMatchB = ( bLow.indexOf( vLow ) === 0 ? 1 : 0 );

return 0;

// Remove duplicates and self-references

for ( i = 0; i < titles.length; i++ ) {

conf.wgNamespaceNumber === 14 && titles[ i ] === conf.wgTitle

) {

}

}

if ( engineName && suggestionConfigs[ engineName ] && !suggestionConfigs[ engineName ].temp ) {

this.inputExists = false;

}

var firstTitle = titles[ 0 ];

var completed = this.autoComplete( firstTitle, v, vNormalized, key, dontAutocomplete );

if ( engineName && suggestionConfigs[ engineName ] && !suggestionConfigs[ engineName ].temp ) {

this.inputExists = existing;

}

if ( titles.length === 1 ) {

this.list.style.display = 'none';

return;

}

}

// (Re-)fill the list

for ( i = 0; i < titles.length; i++ ) {

var opt = make( 'option' );

if ( !this.is_active ) {

this.list.style.display = 'none';

return;

}

this.list.size = nofItems;

this.list.style.align = is_rtl ? 'right' : 'left';

// Approximate calculation of maximum list size

var maxListHeight = listh;

 

function viewport( what ) {

if ( is_webkit && !document.evaluate ) {

return window[ 'inner' + what ];

}

var s = 'client' + what;

return ( document.documentElement ? document.documentElement[ s ] : 0 ) || document.body[ s ] || 0;

}

// IE >= 8: 0 at the far right, then increasingly positive values.

// Webkit: scrollWidth - clientWidth at the far right, then down to zero.

// Opera: don't know...

// Now all have webkit behavior, i.e. zero if at the leftmost edge.

}

};

}

do {

node = node.offsetParent;

} while ( node );

}

 

if ( this.engineName ) {

this.engineSelector.style.zIndex = 5;

if ( this.engineSelector.style.display === 'none' ) {

this.engineSelector.style[ anchor ] = '-10000px';

this.engineSelector.style.display = '';

offset = this.engineSelector.offsetHeight;

}

if ( textPos.y < maxListHeight + offset + 1 ) {

nt = this.text.offsetHeight + offset + 1;

} else {

nt = -listh - offset - 1;

}

this.list.style.top = nt + 'px';

w = view_w;

this.list.style.width = w + 'px';

}

var relative_offset = 0;

}

},

 

autoComplete: function ( newVal, actVal, normalizedActVal, key, dontModify ) {

// If we can't select properly or an IME composition is ongoing, autocompletion would be a major annoyance to the user.

// Maybe it'll work with the normalized value (NFC)?

if ( normalizedActVal && newVal.indexOf( normalizedActVal ) === 0 ) {

actVal = normalizedActVal;

} else {

canSelect: function () {

return this.text.setSelectionRange ||

},

 

setSelection: function ( from, to ) {

// this.text must be focused (at least on IE)

if ( this.text.setSelectionRange ) { // e.g. khtml

this.text.setSelectionRange( from, to );

if ( from > this.text.selectionStart ) {

this.text.selectionEnd = to;

 

getSelection: function () {

// this.text must be focused (at least on IE)

if ( !this.text.value ) {

// No text.

from = this.text.selectionStart;

to = this.text.selectionEnd;

from = textRng.text.length;

} catch ( notFocused ) {

}

}

}

},

 

break;

case PGUP:

break;

case PGDOWN:

break;

case ESC: // Inhibit default behavior (revert to last real input in FF: we do that ourselves)

if ( dir ) {

if ( this.list.style.display !== 'none' ) {

this.highlightSuggestion( dir );

// Kill the event, otherwise some browsers (e.g., Firefox) may additionally treat an up-arrow

} else if (

this.keyCount <= 1 &&

// If no suggestions displayed, get them, unless we're already getting them.

this.textchange();

 

highlightSuggestion: function ( dir ) {

var curr = this.list.selectedIndex;

var tgt = -1;

if ( dir === 0 ) {

tgt = curr;

} else {

tgt = curr < 0 ? 0 : curr + dir;

tgt = tgt < 0 ? 0 : tgt;

}

if ( tgt !== curr || dir === 0 ) {

this.list.options[ tgt ].selected = true;

// Get current input text

if ( !completed || this.list.options[ tgt ].text === this.lastRealInput ) {

this.text.value = this.list.options[ tgt ].text + key;

}

this.lastInput = this.list.options[ tgt ].text;

this.inputExists = true; // Might be wrong if from a dab list...

this.state = CategoryEditor.CHANGE_PENDING;

}

 

resetKeySelection: function () {

var curr = this.list.selectedIndex;

if ( curr >= 0 && curr < this.list.options.length ) {

return false;

}

}; // end CategoryEditor.prototype

 

function initialize() {

// override it easily in their own user script files by just declaring variables. JSconfig

// is some feature used at Wikimedia Commons.

}

// Numeric input, make sure we have a numeric value

// Localize search engine names

}

// Catch both native RTL and "faked" RTL through [[MediaWiki:Rtl.js]]

case 'cologneblue':

container = document.getElementById( 'quickbar' );

case 'standard':

case 'nostalgia':

var lks = container.getElementsByTagName( 'a' );

for ( var i = 0; i < lks.length; i++ ) {

}

return false;

// all modern skins:

return document.getElementById( 'ca-edit' ) !== null;

}

}

if ( !ip ) {

ip = document.getElementById( 'wpDestFile' );

}

var reupload = document.getElementById( 'wpForReUpload' );

var destFile = document.getElementById( 'wpDestFile' );

// Insert a table row with two fields (label and empty category bar)

var labelCell = make( 'td' );

// Create the label

var label = null;

try {

label = UFUI.getLabel( 'wpCategoriesUploadLbl' );

if ( !label ) {

labelCell.id = 'hotcatLabel';

} else {

labelCell.id = 'hotcatLabelTranslated';

if ( oldSubmit ) {

if ( typeof oldSubmit === 'string' ) {

do_submit = eval( oldSubmit );

do_submit = oldSubmit.apply( form, arguments );

}

}

closeForm();

// Copy the categories

var addedOne = false;

for ( var i = 0; i < editors.length; i++ ) {

var t = editors[ i ].currentCategory;

var key = editors[ i ].currentKey;

// Only add if not already present

var cleanedText = eb.value

}

if ( addedOne ) {

eb.value = eb.value.replace( /\{\{subst:unc\}\}/g, '' );

}

 

function isOnPage( span ) {

catTitle = catTitle.substr( catTitle.indexOf( ':' ) + 1 ).replace( /_/g, ' ' );

if ( cleanedText === null ) {

cleanedText = pageText

 

function findByClass( scope, tag, className ) {

return ( result && result.length ) ? result[ 0 ] : null;

}

 

function setup( additionalWork ) {

initialized = true;

if ( setupTimeout ) {

if ( !hiddenCats ) {

footer = findByClass( document, 'div', 'printfooter' );

}

catLine = make( 'div' );

var label = make( 'a' );

label.href = conf.wgArticlePath.replace( '$1', 'Special:Categories' );

catLine.appendChild( label );

catLine.appendChild( make( ':', true ) );

container.className = 'catlinks noprint';

container.style.display = '';

} // end if catLine exists

 

// Create editors for all existing categories

var i;

var cats = line.getElementsByTagName( 'li' );

} else {

cats = line.getElementsByTagName( 'span' );

// Copy cats, otherwise it'll also magically contain our added spans as it is a live collection!

var copyCats = new Array( cats.length );

for ( i = 0; i < copyCats.length; i++ ) {

var test = isOnPage( copyCats[ i ] );

new CategoryEditor( line, copyCats[ i ], test.title, test.match[ 2 ], is_hidden );

}

}

}

 

if ( !onUpload ) {

if ( pageText !== null && hiddenCats ) {

createEditors( hiddenCats, true );

}

var enableMulti = make( 'span' );

enableMulti.className = 'noprint';

catLine.insertBefore( enableMulti, catLine.firstChild.nextSibling );

enableMulti.appendChild( make( '\xa0', true ) ); // nbsp

multiSpan = make( 'span' );

enableMulti.appendChild( multiSpan );

var lk = multiSpan.getElementsByTagName( 'a' )[ 0 ];

lk.style.cursor = 'pointer';

}

cleanedText = null;

$( 'body' ).trigger( 'hotcatSetupCompleted' );

}

 

function createCommitForm() {

var formContainer = make( 'div' );

formContainer.style.display = 'none';

formContainer.innerHTML =

'<form id="hotcatCommitForm" method="post" enctype="multipart/form-data" action="' +

'</form>';

commitForm = document.getElementById( 'hotcatCommitForm' );

function getPage() {

// We know we have an article here.

pageText = '';

pageTime = null;

} else {

var url = conf.wgServer + conf.wgScriptPath + '/api.php?format=json&callback=HotCat.start&action=query&rawcontinue=&titles=' +

var s = make( 'script' );

document.getElementsByTagName( 'head' )[ 0 ].appendChild( s );

}

}

 

function setState( state ) {

var cats = state.split( '\n' );

if ( initialized && editors.length === 1 && editors[ 0 ].isAddCategory ) {

// Insert new spans and create new editors for them.

var i;

for ( i = 0; i < cats.length; i++ ) {

var cat = cats[ i ].split( '|' );

var key = cat.length > 1 ? cat[ 1 ] : null;

cat = cat[ 0 ];

lk.appendChild( make( cat, true ) );

lk.title = cat;

var span = make( 'span' );

span.appendChild( lk );

catLine.insertBefore( span, before );

}

// And change the last one...

for ( i = 0; i < newSpans.length; i++ ) {

new CategoryEditor( catLine, newSpans[ i ].element, newSpans[ i ].title, newSpans[ i ].key );

}

}

return null;

}

 

// Export legacy functions

 

// Make sure we don't get conflicts with AjaxCategories (core development that should one day

// Reload HotCat after (VE) edits (bug T103285)

mw.hook( 'postEdit' ).add( function () {

catLine = null;

editors = [];

initialized = false;

run();

} );

}

 

}( jQuery, mediaWiki ) );

// </nowiki>