:User:Hall Monitor/popups.js

var popupVersion="Sun Sep 25 13:14:45 EDT 2005";

// CONTENTS

// Utility functions

// Popup stuff

// global variables

// html generation

// downloading

// link generation

// manipulation functions

// tests

// actions

// thingies

////////////////////////////////////////////////////////////////////

// Utility functions

////////////////////////////////////////////////////////////////////

function time() {

var d=new Date();

return d.getHours() + ':' + d.getMinutes() + ':' + d.getSeconds() +

'.' + (d.getTime() % 1000);

};

var gMsg='';

function log(x) { if(gMsg!='')gMsg += '\n'; gMsg+=time() + ' ' + x; };

function myalert(x) { return alert(time()+'\n'+ x); };

////////////////////////////////////////////////////////////////////

// Popup stuff

////////////////////////////////////////////////////////////////////

// livepreview uses a broken hex_md5 function, so we avoid it

function md5_hex(s) { return rstr2hex(rstr_md5(str2rstr_utf8(s))); };

/////////////////////

// GLOBAL VARIABLES //

//////////////////////

// regexes

var exceptions=RegExp('((title=|/)Special:|section=[0-9])') ;

var contributions=RegExp('(title=|/)Special:Contributions(&target=|/|/User:)(.*)') ;

var emailuser= RegExp('(title=|/)Special:Emailuser' +'(&target=|/|/User:)(.*)') ;

var talk=RegExp('Talk:', 'i') ;

// (^|\[\[)image: *([^|\]]*[^|\] ]) *

// (^|\[\[)image: *([^|\]]*[^|\] ])([^0-9\]]*([0-9]+) *px)?

// $4 = 120 as in 120px

var imageRegex= RegExp('(^|\\[\\[)image: *([^|\\]]*[^|\\] ])([^0-9\\]]*([0-9]+) *px)?',

'img') ;

var imageRegexBracketCount = 4;

var categoryRegex= RegExp('\\[\\[category: *([^|\\]]*[^|\\] ]) *', 'i') ;

var categoryRegexBracketCount = 1;

var stubRegex= RegExp('stub[}][}]|This .*-related article is a .*stub', 'im') ;

var disambigRegex=

RegExp('([{][{]disambig|disambig[}][}]|dab[}][}])' +

'|is a .*disambiguation.*page', 'im') ;

var ipUserRegex=RegExp('(User:)?' +

'((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){3}' +

'(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])');

var oldidRegex=RegExp('[?&]oldid=([0-9]*)');

var splitLoc=window.location.href.split('/');

var thisWiki=splitLoc[2];

var wikimediaWiki=RegExp('wiki\([pm]edia\|source\|books\)\.org\|wiktionary\.org').test(thisWiki);

var localWiki=RegExp('^localhost').test(thisWiki);

var protocol=splitLoc[0].split(':')[0];

var titletail='/index.php?title=';

if (wikimediaWiki) titletail = '/w' + titletail;

else if (localWiki) titletail = '/wiki' + titletail;

// eg sourceJS('http://www.bosrup.com/web/overlib/overlib.js');

function sourceJS(url) {

var str='';

return document.write(str);

};

// eg sourceWikipediaJS('en.wikipedia.org', 'User:Lupin/overlib.js');

function sourceWikipediaJS(wiki, name) {

var url='http://' + wiki + titletail;

url += name;

url += '&action=raw&ctype=text/javascript&dontcountme=s';

return sourceJS(url);

};

// eg sourceLupinJS('overlib');

function sourceLupinJS(name) {

return sourceWikipediaJS('en.wikipedia.org', 'User:Lupin/'+name + '.js');

};

// /REGEX

// we're not set up for interwiki stuff yet - only affect en, commons

// and wiktionary links

var reStart='[^:]*://';

var preTitles='wiki/|w/index\\.php\\?title=';

if (!wikimediaWiki) {

preTitles = 'wiki/index\\.php\\?title=|wiki/index\\.php/|'+preTitles

+ '|index\\.php\\?title=' ;

}

var reEnd='/(' + preTitles + ')([^&?]*)';

var re = RegExp(reStart + thisWiki.split('.').join('\\.') + reEnd);

var titlebase=protocol+'://'+thisWiki+titletail;

var wikibase=protocol+'://'+thisWiki+'/wiki/';

var popupImageSize=60;

var imageSources=new Array ();

var commonsWiki='commons.wikimedia.org';

// frequently seen thumbs

imageSources.push(

{wiki: thisWiki, thumb: true, width: 180}, // default

{wiki: thisWiki, thumb: true, width: 120} // gallery

);

// frequently seen thumbs on commons

if (wikimediaWiki && thisWiki!=commonsWiki) {

imageSources.push(

{wiki: commonsWiki, thumb: true, width: 180},

{wiki: commonsWiki, thumb: true, width: 120}

);

}

// unusual thumb sizes and full-size

imageSources.push(

{wiki: thisWiki, thumb: true, width: 200}, // common?

{wiki: thisWiki, thumb: true, width: 250}, // common?

{wiki: thisWiki, thumb: true, width: 300},

{wiki: thisWiki, thumb: true, width: 210},

{wiki: thisWiki, thumb: true, width: 230},

{wiki: thisWiki, thumb: false, width: 0} // no comma

);

// full-size on commons

if (wikimediaWiki && thisWiki!=commonsWiki) {

imageSources.push({wiki: commonsWiki, thumb: false, width: 0});

}

// downloading images are put here

var imageArray=new Array();

// page caching

var gCachedPages = new Array ();

var gImageCache = new Array();

// FIXME what is this for?

var gImage=null; // global for image

// check to see if images are done with this timer

var popupImageTimer=null;

// misc debug messages

var popupDebug=null;

// These are for checkImages()

var counter=0;

var checkImagesTimer=null;

var loopcounter=0;

// ids change with each popup: popupImage0, popupImage1 etc

var popupImageId=0;

var kateBase='http://kohl.wikimedia.org/~kate/cgi-bin/count_edits'

+ '?dbname='

switch(thisWiki) {

case commonsWiki: kateBase += 'commonswiki';

break;

case 'en.wiktionary.org': kateBase += 'enwiktionary';

break;

default: kateBase += 'enwiki';

}

kateBase += '&user=';

// for myDecodeURI

var decodeExtras = new Array ();

decodeExtras.push (

{from: '%2C', to: ',' },

{from: '_', to: ' ' },

{from: '%26', to: '&' } // no ,

);

// for setPopupHTML - needed for timers and stuff

var popupHTMLTimers=new Array();

var popupHTMLLoopFunctions = new Array();

// FIXME - eliminate this

var redirCount=0;

// Cookie handling

// pasted straight from http://www.quirksmode.org/js/cookies.html

function createCookie(name,value,days)

{

if (days)

{

var date = new Date();

date.setTime(date.getTime()+(days*24*60*60*1000));

var expires = "; expires="+date.toGMTString();

}

else var expires = "";

document.cookie = name+"="+value+expires+"; path=/";

};

function readCookie(name)

{

var nameEQ = name + "=";

var ca = document.cookie.split(';');

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

{

var c = ca[i];

while (c.charAt(0)==' ') c = c.substring(1,c.length);

if (c.indexOf(nameEQ) == 0) return c.substring(nameEQ.length,c.length);

}

return null;

};

function eraseCookie(name)

{

createCookie(name,"",-1);

};

// options

// if there's no cookie, this should expand to something like

// if (window.foo===null) window.foo=window.dfoo;

function defaultize(x) {

var val=null;

var a='window.'+x;

var b='window.d'+x;

if (x!='popupCookies') {

defaultize('popupCookies');

if (popupCookies && (val=readCookie(x))) {

eval(a + '=' + val + ';');

return;

}

}

eval('if ('+a+'===null) '+a+'=' + b + ';');

};

// this should expand to something like

// if (typeof window.foo=='undefined') { window.foo=null; }; window.dfoo = 0.5;

function newOption(x, def) {

var a='window.' + x;

var b='window.d' + x;

eval('if (typeof '+ a + '==\'undefined\') {' + a + '=null; }; ' +

b + '=' + def + ';');

};

function getValueOf(varName) {defaultize(varName); return eval(varName);};

// user-settable parameters and defaults

newOption('popupDelay', 0.5);

newOption('removeTitles', true);

newOption('imagePopupsForImages', true);

newOption('popupSummaryData', true);

newOption('simplePopups', false);

newOption('popupAdminLinks', false);

newOption('popupImages', true);

newOption('popupPreviews', true);

newOption('popupMaxPreviewSentences', 4);

newOption('popupMaxPreviewCharacters', 600);

newOption('popupNavLinks', true);

newOption('popupNavLinkSeparator', "' ⋅ '");

newOption('popupOnlyArticleLinks', true);

newOption('popupNeverGetThumbs', false);

newOption('popupImagesFromThisWikiOnly', false);

newOption('popupAppendRedirNavLinks', true);

newOption('popupMaxWidth', 300);

newOption('popupSimplifyMainLink', true);

newOption('popupMinImageWidth', 50);

newOption('popupLastEditLink', true);

newOption('popupHistoricalLinks', true);

newOption('popupFixRedirs', true);

newOption('popupLiveOptions', false);

newOption('popupCookies', false);

newOption('popupUnsimplifyLink', false);

newOption('popupLoadImagesSequentially', false);

newOption('popupShortcutKeys', false);

newOption('popupLiveOptionsExpanded', false);

newOption('popupFixDabs', false);

newOption('popupImagesToggleSize',true);

// browser-specific hacks

// if (typeof window.opera != 'undefined') {}

if ((self.navigator.appName)=='Konqueror') {

dpopupNavLinkSeparator=' • ';

} else if ((self.navigator.appName).indexOf("Microsoft")!=-1) {

dpopupNavLinkSeparator=' · ';

}

// String.prototype.parenSplit should do what ECMAscript says

// String.prototype.split does, interspersing paren matches between

// the split elements

if (String('abc'.split(/(b)/))!='a,b,c') {

// broken String.split, e.g. konq, IE

String.prototype.parenSplit=function (re) {

var m=re.exec(this);

if (!m) return [this];

// without this, we have

// 'ab'.parenSplit(/a|(b)/) != 'ab'.split(/a|(b)/)

for(var i=0; i

if (typeof m[i]=='undefined') m[i]='';

}

return [this.substring(0,m.index)]

.concat(m.slice(1))

.concat(this.substring(m.index+m[0].length).parenSplit(re));

};

} else {

String.prototype.parenSplit=function (re) {return this.split(re);};

}

/////////////////////

// HTML GENERATION //

/////////////////////

// generate html for popup image

//

// where n=popupImageId

function imageHTML(article) {

var ret='';

popupImageId++;

ret += '';

ret += '

+ 'style="display: none;">';

ret += '';

return ret;

};

function isInToc(a) {

return isSubElementOf(a,'toc');

};

function isInArticle(a) {

// content is for monobook.. damn. was hoping to avoid skin references

if (document.getElementById('article')) return isSubElementOf(a, 'article');

else return isSubElementOf(a, 'content');

};

function isSubElementOf(a, tag) {

var obj = a;

var i=0;

// this may well slow things down when this function is iterated

// would perhaps be more efficient to cache this result before the

// function is called. or maybe the browser does that magically anyway

var tagged=document.getElementById(tag);

if (!tagged) return false;

do {obj = obj.parentNode; ++i; }

while (obj != tagged && obj.nodeName != 'HTML');

if (obj.nodeName == 'HTML') return false;

return true;

};

function articleFromURL(h) {

if (typeof h != 'String') h=String(h);

var article=null;

var contribs=contributions.exec(h);

if (contribs != null) {

article='User:'+contribs[3];

return article;

}

var email=emailuser.exec(h);

if (email != null) {

article='User:'+email[3];

return article;

}

// no more special cases to check --

// hopefully it's not a disguised user-related page

var m=re.exec(h);

if(m===null) return null;

article=m[2];

return article;

};

function articleFromAnchor(a) {var h=a.href; return articleFromURL(h);};

function oldidFromAnchor(a) {

// log('oldidFromAnchor');

var h=a.href;

var m=oldidRegex.exec(h);

if (m) return m[1];

return null;

};

// Generate html for whole popup

function popupHTML (a) {

var article = articleFromAnchor(a);

var html='';

html +=imageHTML(article);

var hint=a.originalTitle;

if (hint == '' || hint == null) hint = safeDecodeURI(article);

var oldid=null;

if (getValueOf('popupHistoricalLinks')) oldid=oldidFromAnchor(a);

if (getValueOf('popupNavLinks')) html += navLinksHTML(article, hint, oldid);

if (getValueOf('popupUnsimplifyLink')) html += popupUnsimplifyHTML();

var popupEmptySpans = ['popupWarnRedir','popupGubbins','popupLiveOptions','popupPreview','popupFixDab'];

for (var i=0; i

return html;

};

function popupUnsimplifyHTML() {

var html = '';

html += '';

html += '
';

html += '

+ 'style="cursor:pointer; border: thin dotted black" '

+ 'title="Download preview data from the Wikipedia servers">'

+ 'Get preview data'

+ '';

html += '';

return html;

};

function popupUnsimplify() {};

function isIpUser(user) {return ipUserRegex.test(user);};

function popupToggleVar(varstring) {

defaultize(varstring);

eval('window.'+varstring+'=!window.' + varstring);

defaultize('popupCookies');

if (popupCookies) createCookie(varstring, String(eval(varstring)));

};

function popupToggleShowOptions (dummy) {

// just update state if dummy is true

defaultize('popupLiveOptionsExpanded');

if (!dummy) window.popupLiveOptionsExpanded=!window.popupLiveOptionsExpanded;

setPopupHTML((window.popupLiveOptionsExpanded) ? '<<' : '>>',

'optionPopped');

var s=document.getElementById('popupOptionsDiv');

// if (!s) return;

if (window.popupLiveOptionsExpanded) s.style.display='inline';

else s.style.display='none';

};

function popupOptionsCheckboxHTML(varstring, label, title) {

var html='
';

html += '';

html += '

html += (eval(varstring)) ? 'checked="checked" ' : '';

html += 'onClick="javascript:popupToggleVar(' + "'" + varstring + "'" +

')">' + label + '';

return html;

};

function popupLiveOptionsHTML() {

var html = '';

html += '
';

html += '

html += 'style="border: thin dotted black; cursor: pointer" ';

html += 'onClick="javascript:popupToggleShowOptions()">';

html += 'Options ';

html += '';

html += '

';

return html;

};

function mainLinkHTML(article, hint, oldid) {

var html='';

var visibleMainLinkText=safeDecodeURI(article);

if ( getValueOf('popupSimplifyMainLink') ) {

var s= visibleMainLinkText.split('/');

visibleMainLinkText = s[s.length-1];

if (visibleMainLinkText == '' && s.length > 1) {

// shouldn't happen...

visibleMainLinkText=s[s.length-2];

}

}

if (typeof hint =='undefined') hint=safeDecodeURI(article);

if (oldid) hint = 'Revision '+ oldid +' of ' + hint;

html+='';

html+=addPopupShortcut(titledWikiLink(article, 'view', visibleMainLinkText, hint, oldid), ' ');

if (oldid)

html+='|' + titledWikiLink(article, 'view', 'cur',

'Current revision of '+visibleMainLinkText);

html+='';

if (getValueOf('popupLastEditLink')) {

html += popupNavLinkSeparator

+ addPopupShortcut(

titledDiffLink(article, 'lastEdit', 'Show the last edit made to '+visibleMainLinkText, 'prev', 'cur')

, '/');

}

if (oldid) {

if (popupLastEditLink) html += '|';

else html += popupNavLinkSeparator;

html += titledDiffLink(article, 'oldEdit',

'Show the edit made to get revision '+ oldid,

'prev', oldid);

html += '|' + titledDiffLink(article, 'diffCur',

'Show differences between revision '+oldid

+' and the current revision',

oldid, 'cur');

}

return html;

};

function emptySpanHTML(name, id) {return '';};

function addLinkProperty(html, property) {

// take "... and add a property

// not sophisticated at all, easily broken

var i=html.indexOf('>');

if (i<0) return html;

return html.substring(0,i) + ' ' + property + html.substring(i);

};

function addPopupShortcut(html, key) {

var ret= addLinkProperty(html, 'popupkey="'+key+'"');

if (key==' ') key='space';

return ret.replace(RegExp('^(.*?)(title=")(.*?)(".*)$', 'i'),'$1$2$3 ['+key+']$4');

};

function userNavLinksHTML(article) {

// contribs - count - email - block

// count only if applicable; block only if popupAdminLinks

var html = '';

html += addPopupShortcut(contribsLink(article, 'contribs'), 'c');

var k = kateLink(article, 'count');

if (k) html += popupNavLinkSeparator + addPopupShortcut(k, '#');

html += popupNavLinkSeparator + addPopupShortcut(emailLink(article, 'email'), 'M');

if (popupAdminLinks) html += popupNavLinkSeparator + addPopupShortcut(blockLink(article, 'block'), 'b');

return html;

};

function reportErrorHTML(err) {

return 'Error: '+err+ ' Please report this!';

};

// this function, rather ugly

function editingNavLinksHTML(article, oldid) {

// edit - history - un|watch - talk|edit|new, OR (if a talk page)

// edit|new - history - un|watch - article|edit

var html = '';

var t=talkPage(article);

if (t) {

// it's not a talk page

if (oldid) {

html += addPopupShortcut(wikiLink(article, 'edit', 'editOld', oldid), 'e')

+ '|' + wikiLink(article, 'edit', 'cur', null);

} else {

html += addPopupShortcut(wikiLink(article, 'edit', 'edit'), 'e');

}

html += popupNavLinkSeparator + addPopupShortcut(wikiLink(article, 'history', 'history'), 'h');

html += popupNavLinkSeparator + wikiLink(article, 'unwatch', 'un')

+ '|' + addPopupShortcut(wikiLink(article, 'watch', 'watch'), 'w');

html += popupNavLinkSeparator +

'' + addPopupShortcut(wikiLink(t, 'view', 'talk'), 't')

+ '' +

'|' + wikiLink(t, 'edit', 'edit') +

'|' + addPopupShortcut(wikiLink(t, 'edit§ion=new', 'new'), '+');

} else {

var ta=articleFromTalkPage(article);

if (!ta) return reportErrorHTML('Not a talk page and not an article.');

// it's a talk page

if (oldid) {

html += addPopupShortcut(wikiLink(article, 'edit', 'editOld', oldid), 'e')

+ '|' + wikiLink(article, 'edit', 'cur', null);

} else {

html += addPopupShortcut(wikiLink(article, 'edit', 'edit'), 'e');

}

html += '|' + addPopupShortcut(wikiLink(article, 'edit§ion=new', 'new'), '+');

html += addPopupShortcut(popupNavLinkSeparator + wikiLink(article, 'history', 'history'), 'h');

html += popupNavLinkSeparator + wikiLink(article, 'unwatch', 'un')

+ '|' + addPopupShortcut(wikiLink(article, 'watch', 'watch'), 'w');

html += popupNavLinkSeparator +

'' + addPopupShortcut(wikiLink(ta, 'view', 'article'), 'a')

+ '' +

'|' + wikiLink(ta, 'edit', 'edit');

}

return html;

};

function miscNavLinksHTML(article) {

// whatLinksHere - relatedChanges - move

var html='';

html += addPopupShortcut(specialLink(article, 'Whatlinkshere', 'whatLinksHere'), 'l');

// shortcut: r

html += popupNavLinkSeparator + addPopupShortcut(specialLink(article, 'Recentchangeslinked', 'relatedChanges'), 'r');

html += popupNavLinkSeparator + addPopupShortcut(specialLink(article, 'Movepage', 'move'), 'm');

return html;

};

function adminNavLinksHTML(article) {

var html = '';

html += wikiLink(article, 'unprotect', 'un') + '|';

html += addPopupShortcut(wikiLink(article, 'protect', 'protect'), 'p');

html += popupNavLinkSeparator + undeleteLink(article, 'un') + '|';

html += addPopupShortcut(wikiLink(article, 'delete', 'delete'), 'd');

return html;

};

function navLinksHTML (article, hint, oldid) {

var html='';

defaultize('popupNavLinkSeparator');

html += mainLinkHTML(article, hint, oldid);

// Get rid of anchor (or whatever the bit after the # is called) now

article=removeAnchor(article);

// span for blinkenlights

html+=emptySpanHTML('popupImageStatus', popupImageId);

if (userName(article) != null) html += '
' + userNavLinksHTML(article);

html += '
' + editingNavLinksHTML(article, oldid);

html += '
' + miscNavLinksHTML(article);

if (getValueOf('popupAdminLinks')) html += '
' + adminNavLinksHTML(article);

return html;

};

/////////////////

// DOWNLOADING //

/////////////////

//////////////

//

// downloader

//

//

function downloader(url) {

// Source: http://jibbering.com/2002/4/httprequest.html

this.http= false;

/*@cc_on @*/

/*@if (@_jscript_version >= 5)

// JScript gives us Conditional compilation,

// we can cope with old IE versions.

// and security blocked creation of the objects.

try {

this.http = new ActiveXObject("Msxml2.XMLHTTP");

} catch (e) {

try {

this.http = new ActiveXObject("Microsoft.XMLHTTP");

} catch (E) {

// this.http = false;

}

}

@end @*/

if (! this.http && typeof XMLHttpRequest!='undefined') this.http = new XMLHttpRequest();

this.url = url; this.id=null;

this.callbackFunction = null;

};

new downloader();

downloader.prototype.send = function (x) {if (!this.http) return; return this.http.send(x);};

downloader.prototype.abort = function () {if (!this.http) return;return this.http.abort();};

downloader.prototype.runCallback = function () {this.callbackFunction(this);};

downloader.prototype.getData = function () {if(!this.http) return; return this.http.responseText;};

downloader.prototype.setTarget = function () {if(!this.http) return; this.http.open("GET", this.url, true);};

downloader.prototype.start=function () {if(!this.http) return; return this.http.send(null);};

downloader.prototype.getReadyState=function () {if(!this.http) return; return this.http.readyState;};

downloader.prototype.setCallback = function (f) {

if(!this.http) return;

this.http.onreadystatechange = f;

this.callbackFunction = f;

};

function newDownload(url, id, callback) {

var d=new downloader(url);

d.id=id;

d.setTarget();

var f = function () {

if (d.getReadyState() == 4)

{ d.data=d.getData(); callback(d);}

};

d.setCallback(f);

return d;//d.start();

};

function fakeDownload(url,id,callback,data) {

var d=newDownload(url,callback);

d.id=id;

d.data=data;

return callback(d);

};

function startDownload(url, id, callback) {var d=newDownload(url, id, callback); d.start();};

//

//

// downloader

//

//////////////

// Schematic for a getWiki call

//

// getWiki->-getPageWithCaching

// |

// false | true

// getPage<-[findPictureInCache]->-onComplete(a fake download)

// \.

// (async)->addPageToCache(download)->-onComplete(download)

function getWiki(wikipage, onComplete, oldid) {

// set global variable (ugh) to holdwikipage

window.currentArticle=wikipage;

// set ctype=text/css to get around opera bug

var url = titlebase + removeAnchor(wikipage) + '&action=raw&ctype=text/css';

if (oldid!=null && oldid!='') url += '&oldid='+oldid;

return getPageWithCaching(url, onComplete);

};

// check cache to see if page exists

function getPageWithCaching(url, onComplete) {

var i=findInPageCache(url);

if (i > -1) return fakeDownload(url, popupImageId, onComplete, gCachedPages[i].data);

return getPage(url, onComplete);

};

function getPage(url, onComplete) {

var callback= function (d) {addPageToCache(d); onComplete(d) };

return startDownload(url, popupImageId, callback);

};

function findInPageCache(url) {

for (var i=0; i

return -1;

};

function cachedPage (url,data) {this.url=url; this.data=data;};

function addPageToCache(download) {

var page = new cachedPage(download.url, download.data);

return gCachedPages.push(page);

};

/*

var gCurrentDownload = null;

function abortCurrentDownload(download) {

if (gCurrentDownload) {

try { gCurrentDownload.abort(); }

catch (anerror) {return 'could not abort download object';}

}

return true;

}

• /

/////////////////////

// LINK GENERATION //

/////////////////////

// titledDiffLink --> titledWikiLink

// wikiLink --> titledWikiLink

// contribsLink, emailLink, blockLink, undeleteLink -> specialLink

// kateLink

function titledDiffLink(article, text, title, from, to) {

return titledWikiLink(article, to + '&oldid=' + from, text, title, null, 'diff');

};

function wikiLink(article, action, text, oldid) {

var prehint=null;

switch (action) {

case 'edit': prehint = 'Edit '; break;

case 'history': prehint = 'Show history for '; break;

case 'unwatch': prehint = 'Stop watching '; break;

case 'watch': prehint = 'Watch '; break;

case 'view': prehint = 'Go to '; break;

case 'unprotect': prehint = 'Unprotect '; break;

case 'protect': prehint = 'Protect '; break;

case 'delete': prehint = 'Delete '; break;

case 'edit§ion=new': prehint = 'Start a new topic on '; break;

default: true;

}

if (action!='edit' && action!='view') oldid=null;

var hint;

if (prehint != null) {

if (oldid) prehint += 'revision '+oldid +' of ';

hint=prehint + safeDecodeURI(article);

}

else hint = safeDecodeURI(article + '&action=' + action)

+ (oldid) ? '&oldid='+oldid : '';

return titledWikiLink(article, action, text, hint, oldid);

};

function titledWikiLink(article, action, text, title, oldid, actionName) {

var base = titlebase + article;

var url=base;

// no need to add action&view, and this confuses anchors

if (typeof actionName=='undefined' || actionName=='') {

actionName='action';

}

if (action != 'view') url = base + '&' + actionName + '=' + action;

var hint='';

if (title != null && title != '')

hint = 'title="' + title + '"';

if (oldid != null && oldid != '')

url+='&oldid='+oldid;

return '' + text + '';

};

function specialLink(article, specialpage, text, sep) {

var base = titlebase + 'Special:'+specialpage;

if (typeof sep == 'undefined' || sep===null) sep='&target=';

var url = base + sep + article;

var prehint=null;

switch (specialpage) {

case 'Whatlinkshere': prehint='Show articles which link to '; break;

case 'Recentchangeslinked': prehint='Show changes in articles related to '; break;

case 'Contributions': prehint='Show contributions made by '; break;

case 'Emailuser': prehint='Email '; break;

case 'Blockip': prehint='Block '; break;

case 'Movepage': prehint='Move '; break;

case 'Undelete': prehint='Show deletion history for '; break;

}

var hint;

if (prehint != null) hint = prehint + safeDecodeURI(article);

else hint = safeDecodeURI(specialpage+':'+article) ;

return '' + text + '';

};

function literalizeRegex(str){

return str.replace(RegExp('([-.()\\+?*^${}\\[\\]])', 'g'), '\\$1');

};

function appendParamsToLink(linkstr, params) {

var sp=linkstr.parenSplit(RegExp('(href="[^"]+?)"', 'i'));

if (sp.length<2) return null;

var ret=sp.shift() + sp.shift();

ret += '&' + params + '"';

ret += sp.join('');

return ret;

};

function changeLinkTargetLink(newTarget, text, hint, summary, clickButton, minor) {

// escape '&' and other nasties

newTarget=encodeURI(newTarget);

text=encodeURI(text);

clickButton=encodeURI(clickButton);

// this'll break if charAt(0) is nasty

var cA=literalizeRegex(decodeURI(window.currentArticle));

var chs=cA.charAt(0).toUpperCase();

chs='['+chs + chs.toLowerCase()+']';

var currentArticleRegexBit=chs+cA.substring(1);

currentArticleRegexBit=currentArticleRegexBit

.split(RegExp('[_ ]', 'g')).join('[_ ]');

// autoedit=s~\[\[([Cc]ad)\]\]~$1~g;s~\[\[([Cc]AD)[|]~[[Computer-aided%20design|~g

var lk=titledWikiLink(removeAnchor(articleFromURL(location.href)),

'edit', text, hint);

var cmd='s~\\[\\[('+currentArticleRegexBit+')\\]\\]~$1~g;';

cmd += 's~\\[\\[('+currentArticleRegexBit+')[|]~[['+newTarget+'|~g';

cmd += '&autoclick='+clickButton;

cmd += '&autominor='+minor;

cmd += '&autosummary='+summary;

return appendParamsToLink(lk, 'autoedit='+cmd);

}

function redirLink(redirMatch) {

/* NB redirMatch is in wikiText */

defaultize('popupAppendRedirNavLinks');

defaultize('popupNavLinks');

defaultize('popupFixRedirs');

var ret='';

if (popupAppendRedirNavLinks && popupNavLinks) {

ret += '

---

';

if (popupFixRedirs && typeof autoEdit != 'undefined' && autoEdit) {

ret += addPopupShortcut(

changeLinkTargetLink(redirMatch, 'Redirects', 'Fix this redirect',

'Bypassing redirect from [[' + window.currentArticle.split('_').join(' ')

+ ']] to ' + redirMatch + '',

'wpDiff', true)

, 'R');

ret += ' to ';

}

else ret += 'Redirects to ';

// BUG: duplicate IDs this way (eg popupImageStatus divs)

// this is a hackish fix

var realPopupImageId=popupImageId;

popupImageId='' + popupImageId + 'redir';

ret += navLinksHTML(wikiMarkupToAddressFragment(redirMatch));

popupImageId=realPopupImageId;

return ret;

}

else return '
Redirects to ' +

titledWikiLink(myEncodeURI(redirMatch), 'view',

safeDecodeURI(redirMatch), 'Bypass redirect');

};

function doNotRedirLink(redirPage, linkText, hintText) {

/* NB redirPage is in wikiText */

return titledWikiLink(myEncodeURI(redirPage), 'edit', linkText, hintText);

};

function contribsLink(article, text) {

return specialLink(userName(article), 'Contributions', text);

};

function emailLink(article, text) {

return specialLink(userName(article), 'Emailuser', text);

};

function blockLink(article, text) {

return specialLink(userName(article), 'Blockip', text, '&ip=');

};

function kateLink(article, text) {

if (isIpUser(userName(article)) || ! wikimediaWiki) return null;

var uN=safeDecodeURI(userName(article));

return '' + text + '';

};

function undeleteLink(article, text) {

return specialLink(article, 'Undelete', text, '/');

};

////////////////////////////

// MANIPULATION FUNCTIONS //

////////////////////////////

function upcaseFirst(str) {

if (typeof str != typeof || str==) return '';

return str.charAt(0).toUpperCase() + str.substring(1);

};

function formatBytes(num) {return (num > 949) ? (Math.round(num/100)/10+'kB') : (num +' bytes') ;};

function popupFilterStubDetect(data) {return (isStub(data)) ? 'stub' : '';};

function popupFilterDisambigDetect(data) {

if (!isDisambig(data)) return '';

if (getValueOf('popupFixDabs') && location.href.indexOf('Special:') == -1)

setPopupHTML(makeFixDab(data), 'popupFixDab', popupImageId);

return 'disambig';

};

function listLinks(wikitext) {

var reg=RegExp('\\[\\[([^|]*?)(\\||\\]\\])', 'gi');

var ret=[];

var splitted=wikitext.parenSplit(reg);

var omitRegex=RegExp('^[a-z]*:|^[Ss]pecial:|^[Ii]mage|^[Cc]ategory');

for (var i=1; i

if (typeof splitted[i] == typeof 'string' && splitted[i].length>0 && !omitRegex.test(splitted[i])) {

ret.push(changeLinkTargetLink(splitted[i],

splitted[i].split(' ').join(' '),

'Disambiguate the this link to '+splitted[i]+'',

'Popups-assisted disambiguation from [[' +

window.currentArticle.split('_').join(' ') + ']] to [['+

splitted[i] + ']]',

'wpDiff', true));

} /* if */

} /* for loop */

return ret.sort(); // FIXME: duplicates not eliminated

};

function makeFixDab(data) {

var list=listLinks(data);

if (list.length==0) return;

var html='

---

Click to disambiguate this link to:
';

html+=list[0];

for (var i=1; i

return html;

};

function popupFilterPageSize(data) {return formatBytes(data.length);};

function popupFilterCountLinks(data) {var num=countLinks(data);return String(num) + ' wikiLink' + ((num!=1)?'s':'');};

function popupFilterCountImages(data) {var num=countImages(data);return String(num) + ' image' + ((num!=1)?'s':'');};

function popupFilterCountCategories(data) {

var num=countCategories(data);

return String(num) + ' categor' + ((num!=1)?'ies':'y');

};

var popupFilters=[popupFilterStubDetect,popupFilterDisambigDetect,popupFilterPageSize,popupFilterCountLinks,

popupFilterCountImages,popupFilterCountCategories];

if (typeof extraPopupFilters=='undefined') { var extraPopupFilters=new Array(); }

function getPageInfo(data) {

if (!data || data.length == 0) return 'Empty page';

var pageInfoArray=new Array();

for (var i=0; i< popupFilters.length; ++i) {var s= popupFilters[i](data);if (s!='') pageInfoArray.push(s);}

for (var i=0; i

var pageInfo=pageInfoArray.join(', ');

if (pageInfo != '' ) pageInfo = upcaseFirst(pageInfo);

return pageInfo;

};

function getValidImageFromWikiText(wikiText) {

var imagePage=null;

// nb in imageRegex we're interested in the second bracketed expression

// this may change if the regex changes :-(

//var match=imageRegex.exec(wikiText);

var matched=null;

var match;

defaultize('popupMinImageWidth');

while ( match = imageRegex.exec(wikiText)) {

/* now find a sane image name - exclude templates by seeking { */

var m = match[2];

var pxWidth=match[4];

if ( isValidImageName(m) && (!pxWidth || parseInt(pxWidth) >= popupMinImageWidth) ) {

matched=m;

break;

}

}

imageRegex.lastIndex=0;

if (!matched) return null;

return 'Image:'+upcaseFirst(matched);

};

function countLinks(wikiText) {

// this could be improved!

return wikiText.split('[[').length - 1;

};

// if N = # matches, n = # brackets, then

// String.parenSplit(regex) intersperses the N+1 split elements

// with Nn other elements. So total length is

// L= N+1 + Nn = N(n+1)+1. So N=(L-1)/(n+1).

function countImages(wikiText) {return (wikiText.parenSplit(imageRegex).length - 1) / (imageRegexBracketCount + 1);};

function countCategories(wikiText) {return (wikiText.parenSplit(categoryRegex).length - 1) / (categoryRegexBracketCount + 1); };

var wikiNamespaces = ["Media", "Special", "Talk", "User", "User talk", "Wikipedia", "Wikipedia talk", "Image",

"Image talk", "MediaWiki", "MediaWiki talk", "Template", "Template talk", "Help", "Help talk",

"Category", "Category talk", "Portal", "Portal talk"];

var wikiTalkNamespaces=["Talk", "User talk", "Wikipedia talk", "Image talk", "MediaWiki talk",

"Template talk", "Help talk", "Category talk", "Portal talk"];

var wikiNamespacesWithTalk=[ null, // NB root (article) namespace is omitted

"User", "Wikipedia", "Image", "MediaWiki", "Template", "Help", "Category", "Portal"];

// returns /^(Talk|User[_ ]talk|Wikipedia[_ ]talk|...):$/

function namespaceListToRegex(list) {return RegExp('^('+list.join('|').split(' ').join('[ _]')+'):');};

function talkPage(article) {

var talkRegex=namespaceListToRegex(wikiTalkNamespaces);

if (talkRegex.exec(article)) {return null;}

var nsRegex=namespaceListToRegex(wikiNamespacesWithTalk);

var splitted=article.parenSplit(nsRegex);

if (splitted.length<2) return (wikiTalkNamespaces[0]+':'+article).split(' ').join('_');

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

if (splitted[1]==wikiNamespacesWithTalk[i]) {

splitted[1]=wikiTalkNamespaces[i];

return splitted.join(':').substring(1).split(' ').join('_');

}

}

return null;

};

function articleFromTalkPage(talkpage) {

var talkRegex=namespaceListToRegex(wikiTalkNamespaces);

var splitted=talkpage.parenSplit(talkRegex);

if (splitted.length < 2 || splitted[0].length > 0) return null;

if (splitted[1]==wikiTalkNamespaces[0]) {

splitted[1]=''; return splitted.join(':').substring(2).split(' ').join('_');

}

for (var i=1; i< wikiTalkNamespaces.length; ++i) {

if (splitted[1]==wikiTalkNamespaces[i]

|| splitted[1]==wikiTalkNamespaces[i].split(' ').join('_')) {

splitted[1]=wikiNamespacesWithTalk[i];

return splitted.join(':').substring(1).split(' ').join('_');

}

}

return null;

};

function userName(article) {

var i=article.indexOf('User');

var j=article.indexOf(':');

if (i != 0 || j < -1) return null;

var k=article.indexOf('/');

if (k==-1) return article.substring(j+1);

else return article.substring(j+1,k);

};

function stripNamespace(article) {

// this isn't very sophisticated

// it just removes everything up to the final :

// BUG: probably does silly things for images with colons in the name - check it out

var list = article.split(':');

return list[list.length-1];

};

// those odd a/a5/ bits of image urls

function imagePathComponent(article) {

var stripped=stripNamespace(article);

var forhash=safeDecodeURI(stripped).split(' ').join('_');

var hash=md5_hex(forhash);

return hash.substring(0,1) + '/' + hash.substring(0,2) + '/';

};

function getImageUrlStart(wiki) { // this returns a trailing slash

switch (wiki) {

case 'en.wikipedia.org': return 'http://upload.wikimedia.org/wikipedia/en/';

case commonsWiki: return 'http://upload.wikimedia.org/wikipedia/commons/';

case 'en.wiktionary.org': return 'http://en.wiktionary.org/upload/en/';

default: // unsupported - take a guess

if (wikimediaWiki) {

var lang=wiki.split('.')[0];

return 'http://' + wiki + '/upload/' + lang +'/';

}

else /* this should work for wikicities */

return 'http://' + wiki + '/images/';

}

};

function imageURL(img, wiki) {

if (getValueOf('popupImagesFromThisWikiOnly') && wiki != thisWiki) return null;

var imgurl=null;

if (isImage(img)) {

var pathcpt = imagePathComponent(img);

var stripped=stripNamespace(img);

imgurl=getImageUrlStart(wiki) + pathcpt + stripped;

}

return imgurl;

};

function imageThumbURL(img, wiki, width) {

//

// eg http://upload.wikimedia.org/wikipedia/en/thumb/6/61/

// Rubiks_cube_solved.jpg/120px-Rubiks_cube_solved.jpg

// ^^^^^^^^^^^^^^^^^^^^^^^

// wikicities omits this bit

// AND wikicities needs a new pathcpt for each filename including thumbs

if (getValueOf('popupImagesFromThisWikiOnly') && wiki != thisWiki) return null;

if (getValueOf('popupNeverGetThumbs')) return null;

var imgurl=null;

if (isImage(img)) {

var stripped=stripNamespace(img);

var pathcpt;

if (wikimediaWiki) pathcpt = imagePathComponent(stripped);

else pathcpt = imagePathComponent(width+'px-'+stripped);

imgurl=getImageUrlStart(wiki) + "thumb/" + pathcpt;

if (wikimediaWiki) imgurl += stripped + '/';

imgurl += width +"px-" + stripped;

}

return imgurl;

};

// (a) myDecodeURI (first standard decodeURI, then exceptions)

// (b) change spaces to underscores

// (c) encodeURI (just the straight one, no exceptions)

function wikiMarkupToAddressFragment (str) { // for images

var ret = safeDecodeURI(str);

ret = ret.split(' ').join('_');

ret = encodeURI(ret);

return ret;

};

function addressFragmentToWikiMarkup (str) {

// seemingly, not :( the inverse of wikiMarkupToAddressFragment

return safeDecodeURI(str);

};

function myDecodeURI (str) {

log('myDecodeURI, str=' + str);

var ret;

try { ret=decodeURI(str); }

catch (summat) { return null; }

for (var i=0; i

var from=decodeExtras[i].from;

var to=decodeExtras[i].to;

ret=ret.split(from).join(to);

}

return ret;

};

function safeDecodeURI(str) {var ret=myDecodeURI(str); return ret || str;};

function myEncodeURI (str) {

log ('myEncodeURI: str='+str);

var ret=str;

ret=encodeURI(ret);

for (var i=0; i

var from=decodeExtras[i].from;

var to=decodeExtras[i].to;

ret=ret.split(to).join(from);

}

return ret;

};

function removeAnchor(article) {

// is there a #? if not, we're done

var i=article.indexOf('#');

if (i == -1) return article;

return article.substring(0,i);

};

///////////

// TESTS //

///////////

function isStub(data) { return stubRegex.test(data); };

function isDisambig(data) { return disambigRegex.test(data); };

function isValidImageName(str){ // extend as needed...

return ( str.indexOf('{') == -1 );

};

function isInNamespace(article, namespace) {

var i=article.indexOf(namespace+':');

var j=article.indexOf(namespace+'_talk:');

if (i == 0 || j == 0) return true;

return false;

};

function isImage(thing) {return isInNamespace(thing, 'Image');};

function isImageOk(img)

{

// IE test

if (!img.complete)

return false;

// gecko test

if (typeof img.naturalWidth != "undefined" && img.naturalWidth == 0)

return false;

// test for konqueror and opera

// note that img.width must not be defined in the html with a width="..."

// for this to work.

// konq seems to give "broken images" width 16, presumably an icon width

// this test would probably work in gecko too, *except for very small images*

if (typeof img.width == 'undefined' || img.width <= 16) return false;

// No other way of checking: assume it's ok.

return true;

};

function anchorContainsImage(a) {

// iterate over children of anchor a

// see if any are images

if (a===null) return false;

kids=a.childNodes;

for (var i=0; i

return false;

};

/////////////

// ACTIONS //

/////////////

var imageCache = new Array ();

function loadThisImage(image) {

if (getValueOf('popupLoadImagesSequentially')) return sequentialLoadThisImage(image);

else return parallelLoadThisImage(image);

};

// this is probably very wasteful indeed of bandwidth

// hey ho

function getImageUrls(image) {

var imageUrls=new Array();

for (var i=0; i

var url;

if (imageSources[i].thumb)

url=imageThumbURL(image, imageSources[i].wiki, imageSources[i].width);

else

url=imageURL(image, imageSources[i].wiki);

for (var j=0; j

if (url == gImageCache[j]) {

loadThisImageAtThisUrl(image, url);

return null;

}

}

if (url!=null) imageUrls.push(url);

}

return imageUrls;

};

function parallelLoadThisImage (image) {

if (!popupImages) return;

if (!isValidImageName(image)) return false;

var imageUrls=getImageUrls(image);

if (!imageUrls) return null;

for (var i=0; i

var url = imageUrls[i];

imageArray[i]=new Image();

imageArray[i].src=url;

}

if (popupImageTimer != null) {

clearInterval(popupImageTimer);

counter=0;

}

gImage=image;

popupImageTimer=setInterval("checkImages()", 250);

return;

};

function nextOne (array, value) {

// NB if the array has two consecutive entries equal

// then this will loop on successive calls

if (typeof array.length == 'undefined') return null;

for (var i=0; i

if (array[i]==value) return array[i+1];

}

return null;

};

function findThis(array, value) {

if (typeof array.length == 'undefined') return null;

for (var i=0; i

if (array[i]==value) return i;

}

return null;

};

// global array for 404'ed image urls

var gBadImageUrls=[];

function sequentialLoadThisImage (image) {

if (!popupImages) return;

if (!isValidImageName(image)) return false;

var imageUrls=getImageUrls(image);

if (!imageUrls) return null;

var img=new Image();

img.isNew=true;

img.popupImageId=popupImageId;

img.counter=1;

img.onload = function () {

// clear status thingy

setImageStatus('');

var i=findThis(imageUrls, this.src);

var goodSrc=this.src;

var setPopupImage=function () {

var popupImage=document.getElementById("popupImage"+this.popupImageId);

if (popupImage && typeof popupImage.src != 'undefined') {

clearInterval(popupImageTimer);

popupImage.src=goodSrc;

popupImage.width=popupImageSize;

popupImage.style.display='inline';

setPopupImageLink(image, imageSources[i].wiki);

} else return;

};

popupImageTimer=setInterval(setPopupImage, 250);

gImageCache.push(goodSrc);

};

img.onerror = function () {

gBadImageUrls.push(this.src);

// if the popup is visible, move on

if (over && over.style.visibility=='visible' && this.popupImageId==popupImageId) this.setNext();

};

img.setNext = function () {

var currentSrc=null;

var newSrc;

if (!this.isNew) currentSrc=this.src;

this.isNew=false;

newSrc= (currentSrc) ? nextOne(imageUrls, currentSrc) : imageUrls[0];

while (findThis(gBadImageUrls, newSrc)) {

newSrc=nextOne(imageUrls, newSrc);

if (!newSrc) {

setImageStatus (' :-(');

return;

}

}

setImageStatus(' '+findThis(imageUrls, newSrc));

this.src=newSrc;

}

// start the ball rolling

img.setNext();

};

function loadThisImageAtThisUrl(image, url) {

//myalert('loading "best" image:\n'+url);

gImage=image;

imageArray = new Array();

imageArray[0] = new Image();

imageArray[0].src=url;

if (popupImageTimer != null) {

clearInterval(popupImageTimer);

counter=0;

}

popupImageTimer=setInterval("checkImages()", 250);

return;

};

function loadImages(article) {if(! isImage(article) ) return; return loadThisImage(article);};

// this has to use a timer loop as we don't know if the DOM element exists when we want to set the text

function setPopupHTML (str, elementId, popupId, onSuccess) {

if (typeof popupId === 'undefined') popupId = popupImageId;

var popupElement=document.getElementById(elementId+popupId);

var timer;

if (typeof popupHTMLTimers[elementId] == 'undefined') timer=null;

else timer=popupHTMLTimers[elementId];

if (popupElement != null) {

if(timer) clearInterval(timer);

popupHTMLTimers[elementId]=null;

popupElement.innerHTML=str;

if (onSuccess) onSuccess();

return true;

} else {

// call this function again in a little while...

var loopFunction=function() { setPopupHTML(str,elementId,popupId,onSuccess);}

popupHTMLLoopFunctions[elementId] = loopFunction;

if (!timer) {

var doThis = 'popupHTMLLoopFunctions["'+elementId+'"]()';

popupHTMLTimers[elementId] = setInterval(doThis, 600);

}

}

};

function setImageStatus(str, id) {return setPopupHTML(str, 'popupImageStatus', id);};

function setPopupTrailer(str,id) {return setPopupHTML(str, 'popupGubbins', id);};

// methinks this is unbelievably silly

// it dovetails with the parallel image loader function

function checkImages() {

if (checkImagesTimer!=null) {

clearInterval(checkImagesTimer);

checkImagesTimer=null;

if (loopcounter > 10); {loopcounter=0; return;}

loopcounter++;

} else counter++;

var status = ( counter % 2 ) ? ':' : '.' ;

setImageStatus(status);

if (counter > 100) {counter = 0; clearInterval(popupImageTimer);}

var popupImage=null;

popupImage=document.getElementById("popupImage"+popupImageId);

if (popupImage == null) {

// this doesn't seem to happen any more in practise for some reason

// still, I'll leave it in

checkImagesTimer=setInterval("checkImages()",333);

return;

}

// get the first image to successfully load

// and put it in the popupImage

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

if(isImageOk(imageArray[i])) {

// stop all the gubbins, assign the image and return

clearInterval(popupImageTimer);

if(isImage(gImage)) {

popupImage.src=imageArray[i].src;

popupImage.width=popupImageSize;

popupImage.style.display='inline';

// should we check to see if it's already there? maybe...

gImageCache.push(imageArray[i].src);

setPopupImageLink(gImage, imageSources[i].wiki);

stopImagesDownloading();

}

setImageStatus('');

// reset evil nonconstant globals

delete imageArray; imageArray=new Array();

popupImageTimer=null;

counter=0;

loopcounter=0;

return popupImage.src;

}

}

};

function stopImagesDownloading() {

gImage=null;

if (imageArray == null) return null;

var i;

for (i=0; i

//imageArray[i].src=''; // this is a REALLY BAD IDEA

delete imageArray[i];

//imageArray[i] = new Image();

}

imageArray = new Array ();

return i;

};

function toggleSize() {

var imgContainer=this;

if (!imgContainer) { alert('imgContainer is null :/'); return;}

img=imgContainer.firstChild;

if (!img) { alert('img is null :/'); return;}

if (!img.style.width || img.style.width=='') img.style.width='100%';

else img.style.width=''; // popupImageSize+'px';

};

function setPopupImageLink (img, wiki) {

if( wiki === null || img === null ) return null;

var a=document.getElementById("popupImageLink"+popupImageId);

if (a === null) return null;

var linkURL = imageURL(img, wiki);

if (linkURL != null) {

if (getValueOf('popupImagesToggleSize')) { a.onclick=toggleSize; a.title='Toggle image size'; }

else { a.href=linkURL; a.title='Open full-size image'; }

}

return linkURL;

};

var ranSetupTooltipsAlready=false;

function setupTooltips() {

if (ranSetupTooltipsAlready) return;

ranSetupTooltipsAlready=true;

var anchors;

// article/content is a skin-dependent thing

if (getValueOf('popupOnlyArticleLinks'))

anchors=( document.getElementById('article') ||

document.getElementById('content') ).getElementsByTagName('A');

else

anchors=document.getElementsByTagName('A');

for (var i=0; i

var a=anchors[i];

var h=a.href;

if (

( (re.test(h) && !exceptions.test(h))

||

(contributions.test(h) && h.indexOf('&limit=') == -1 )

)

&& (! isInToc(a))

) {

a.onmouseover=mouseOverWikiLink;

a.onmouseout= mouseOutWikiLink;

a.onclick= killPopup;

if (getValueOf('removeTitles') && typeof a.originalTitle=='undefined') {

a.originalTitle=a.title;

a.title='';

}

}

}

};

//////////////

// THINGIES //

//////////////

// How the URLs for images in the popup come about

// loadPreviewImage

// |

// getWiki

// |<----------------see other schematic for details

// insertPreviewImage (insertPreviewImage = onComplete)

// |

// | insertPreviewImage gets a wikiText fragment from

// | the wikiText downloaded by getWiki

// |

// [wikiMarkupToAddressFragment]

// |

// | mouseOverWikiLink (gets an "address fragment",

// | | no processing needed)

// \->-loadThisImage---<----loadImages

// |

// [image(Thumb)URL]-->--hopefully valid image urls

var currentLink=null;

function popupHandleKeypress(evt) {

var keyCode = evt.keyCode ? evt.keyCode : evt.charCode ? evt.charCode : evt.which;

if (!keyCode || !over) return;

var letter=String.fromCharCode(keyCode);

var links=over.getElementsByTagName('A');

var startLink=0;

if (window.lastPopupLinkSelected) {

for (var i=0; i

if (links[i]==window.lastPopupLinkSelected) startlink=i;

}

}

for (var j=0; j

var i=(startLink + j) % links.length;

if (links[i].getAttribute('popupkey')==letter)

{

if (evt.preventDefault) evt.preventDefault();

links[i].focus();

window.lastPopupLinkSelected=links[i];

}

}

};

function addPopupShortcuts() {

if (document.onkeypress==popupHandleKeypress) return;

document.oldPopupOnkeypress=document.onkeypress;

document.onkeypress=popupHandleKeypress;

};

function rmPopupShortcuts() {

if (String(document.oldPopupOnkeypress)==String(popupHandleKeypress)) {

// panic

document.onkeypress=function () {};

return;

}

document.onkeypress=document.oldPopupOnkeypress;

};

// add CSS class to table

function addPopupStylesheetClasses () {

var tables=over.getElementsByTagName('table');

tables[0].className='popupBorderTable';

tables[1].className='popupTable';

var fonts=over.getElementsByTagName('font');

fonts[0].className='popupFont';

fonts[0].id='overFontWrapper';

};

function mouseOverWikiLink() {

// FIXME: should not generate the HTML until the delay has elapsed,

// and then popup immediately. Can be a CPU hog otherwise.

var a=this;

// try not to duplicate effort

if (a==currentLink) return;

currentLink=a;

var html = popupHTML(a);

var article=articleFromAnchor(a);

var oldid=oldidFromAnchor(a);

if (popupImageTimer != null) {

clearInterval(popupImageTimer);

counter=0;

}

// keep this (or fix other refs)

defaultize('popupImages');

defaultize('popupMaxWidth');

log('running overlib now');

if (typeof popupMaxWidth == 'number') {

window.setmaxwidth = function () {

over.style.maxWidth = popupMaxWidth+'px';

// hack for IE

// see http://www.svendtofte.com/code/max_width_in_ie/

// who knows if this will work? not me.

// use setExpression as documented here on msdn: http://tinyurl.com/dqljn

if (over.style.setExpression) {

over.style.setExpression('width',

'document.body.clientWidth > '

+ popupMaxWidth + ' ? "'

+ popupMaxWidth + 'px": "auto" );');

}

};

registerHook("createPopup", window.setmaxwidth, FAFTER);

}

if (getValueOf('popupShortcutKeys')) {

registerHook("createPopup", window.addPopupShortcuts, FAFTER);

registerHook("hideObject", window.rmPopupShortcuts, FAFTER);

}

registerHook("createPopup", window.addPopupStylesheetClasses, FAFTER);

overlib(html, STICKY, WRAP, CELLPAD, 5, OFFSETX, 2, OFFSETY, 2,

DELAY, getValueOf('popupDelay')*1000);

if (getValueOf('popupLiveOptions')) {

setPopupHTML(popupLiveOptionsHTML(), 'popupLiveOptions', popupImageId,

function () { popupToggleShowOptions(true); } );

}

if(getValueOf('simplePopups')) return;

// dunno what this is doing here

// FIXME: what is going on?

window.popupUnsimplify = function () {

var previewImage=true;

gImage=null;

if (isImage(article) && ( getValueOf('imagePopupsForImages') || ! anchorContainsImage(a) )) {

loadImages(article);

}

else if (!isImage(article) && previewImage) {

redirCount=0;

loadPreviewImage(article, oldid);

}

var s=document.getElementById('popupUnsimplifySpan' + popupImageId);

if (s && s.style) {

s.style.display='none';

}

};

if (getValueOf('popupUnsimplifyLink')) return;

window.popupUnsimplify();

};

function loadPreviewImage(article, oldid) {return getWiki(article, insertPreviewImage, oldid);};

function loadPreviewImageFromRedir(redirPage, redirMatch) {

/* redirMatch is a regex match */

var target = redirMatch[1];

var trailingRubbish=redirMatch[2];

++redirCount;

var warnRedir = redirLink(target);

setPopupHTML(warnRedir, 'popupWarnRedir');

return loadPreviewImage(myEncodeURI(target));

};

// header...!___ -> ...

function extractChunk(str, header, breakChar) {

if (str.indexOf(header) != 0) return null;

if (!breakChar) return str.substring(header.length);

var findChar=str.indexOf(breakChar);

if (findChar==-1) return str.substring(header.length);

return str.substring(header.length, findChar);

};

function urlToWikiPage (url) {

log ('urlToWikiPage\nurl='+url);

var urlFragment=null;

if (!urlFragment) urlFragment=extractChunk(url, titlebase, '&');

if (!urlFragment) urlFragment=extractChunk(url, wikibase, '?');

if (!urlFragment) return null;

return addressFragmentToWikiMarkup(urlFragment);

};

function insertPreviewImage(download) {

if (download.id != popupImageId) return;

var wikiText=download.data;

var redirectRegex= RegExp('^[ \\n]*[#]redirect[: \\n]*\\[\\[([^\\]]*)\\]\\]\\s*(.*)', 'i') ;

var redirMatch = redirectRegex.exec(wikiText);

if (redirMatch && redirCount==0) {

return loadPreviewImageFromRedir(urlToWikiPage(download.url), redirMatch);

} else redirCount=0;

if (getValueOf('popupSummaryData')) {

var pgInfo=getPageInfo(wikiText);

setPopupTrailer('
' + pgInfo);

}

var imagePage=getValidImageFromWikiText(wikiText);

if(imagePage) {

// loadThisImage expects an "address fragment"

imagePage = wikiMarkupToAddressFragment(imagePage);

defaultize('popupLoadImagesSequentially');

loadThisImage(imagePage);

}

if (getValueOf('popupPreviews')) {popupPreview(download);}

};

var localTest=false;

// possibly the daftest thing so far

// split this up, for crying out loud

function popupPreview(download) {

// FIXME: horizonal rules should be skipped

// FIXME: get rid of html tagsx

if (localTest)

var data = download.substring(0,8000); // FOR TESTING

else {

if (!download || typeof download.data=='undefined'

|| typeof download.data.length=='undefined') return;

var data=download.data.substring(0,10000); // huge pages be gone

}

var datum=new Array();

datum.push(data.substring(0,1000));

// we strip in order:

//

// * html comments

// * contents of ...

';do{this._endline(_parse_inline_nowiki(this.lines[0].substring(1,this.lines[0].length))+"\n");}while(this.lines.length&&this.lines[0].charAt(0)==' ');this.html+='