Revised test data

Testing against the output of cook.rb isn't satisfactory because of the
bugs in it; instead we're now going to test against the tiddlywiki.com
build products

test/tiddlywiki.2.6.5/source/tiddlywiki/js/AdaptorBase.js

@@ -0,0 +1,90 @@
+//--
+//-- Server adaptor base class
+//--
+
+function AdaptorBase()
+{
+	this.host = null;
+	this.store = null;
+	return this;
+}
+
+AdaptorBase.prototype.close = function()
+{
+	return true;
+};
+
+AdaptorBase.prototype.fullHostName = function(host)
+{
+	if(!host)
+		return '';
+	host = host.trim();
+	if(!host.match(/:\/\//))
+		host = 'http://' + host;
+	if(host.substr(host.length-1) == '/')
+		host = host.substr(0,host.length-1);
+	return host;
+};
+
+AdaptorBase.minHostName = function(host)
+{
+	return host;
+};
+
+AdaptorBase.prototype.setContext = function(context,userParams,callback)
+{
+	if(!context) context = {};
+	context.userParams = userParams;
+	if(callback) context.callback = callback;
+	context.adaptor = this;
+	if(!context.host)
+		context.host = this.host;
+	context.host = this.fullHostName(context.host);
+	if(!context.workspace)
+		context.workspace = this.workspace;
+	return context;
+};
+
+// Open the specified host
+//#   host - uri of host (eg, "http://www.tiddlywiki.com/" or "www.tiddlywiki.com")
+//#   context is itself passed on as a parameter to the callback function
+//#   userParams - user settable object object that is passed on unchanged to the callback function
+//#   callback - optional function to be called on completion
+//# Return value is true if the request was successfully issued, false if this connector doesn't support openHost(),
+//#   or an error description string if there was a problem
+//# The callback parameters are callback(context)
+//#   context.status - true if OK, string if error
+//#   context.adaptor - reference to this adaptor object
+//#   userParams - parameters as originally passed into the openHost function
+AdaptorBase.prototype.openHost = function(host,context,userParams,callback)
+{
+	this.host = host;
+	context = this.setContext(context,userParams,callback);
+	context.status = true;
+	if(callback)
+		window.setTimeout(function() {context.callback(context,userParams);},10);
+	return true;
+};
+
+// Open the specified workspace
+//#   workspace - name of workspace to open
+//#   context - passed on as a parameter to the callback function
+//#   userParams - user settable object object that is passed on unchanged to the callback function
+//#   callback - function to be called on completion
+//# Return value is true if the request was successfully issued
+//#   or an error description string if there was a problem
+//# The callback parameters are callback(context,userParams)
+//#   context.status - true if OK, false if error
+//#   context.statusText - error message if there was an error
+//#   context.adaptor - reference to this adaptor object
+//#   userParams - parameters as originally passed into the openWorkspace function
+AdaptorBase.prototype.openWorkspace = function(workspace,context,userParams,callback)
+{
+	this.workspace = workspace;
+	context = this.setContext(context,userParams,callback);
+	context.status = true;
+	if(callback)
+		window.setTimeout(function() {callback(context,userParams);},10);
+	return true;
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Animator.js

@@ -0,0 +1,46 @@
+//-
+//- Animation engine
+//-
+
+function Animator()
+{
+	this.running = 0; // Incremented at start of each animation, decremented afterwards. If zero, the interval timer is disabled
+	this.timerID = 0; // ID of the timer used for animating
+	this.animations = []; // List of animations in progress
+	return this;
+}
+
+// Start animation engine
+Animator.prototype.startAnimating = function() //# Variable number of arguments
+{
+	var t;
+	for(t=0; t<arguments.length; t++)
+		this.animations.push(arguments[t]);
+	if(this.running == 0) {
+		var me = this;
+		this.timerID = window.setInterval(function() {me.doAnimate(me);},10);
+	}
+	this.running += arguments.length;
+};
+
+// Perform an animation engine tick, calling each of the known animation modules
+Animator.prototype.doAnimate = function(me)
+{
+	var a = 0;
+	while(a < me.animations.length) {
+		var animation = me.animations[a];
+		if(animation.tick()) {
+			a++;
+		} else {
+			me.animations.splice(a,1);
+			if(--me.running == 0)
+				window.clearInterval(me.timerID);
+		}
+	}
+};
+
+Animator.slowInSlowOut = function(progress)
+{
+	return(1-((Math.cos(progress * Math.PI)+1)/2));
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Backstage.js

@@ -0,0 +1,187 @@
+//--
+//-- Backstage
+//--
+// Backstage tasks
+config.tasks.save.action = saveChanges;
+
+var backstage = {
+	area: null,
+	toolbar: null,
+	button: null,
+	showButton: null,
+	hideButton: null,
+	cloak: null,
+	panel: null,
+	panelBody: null,
+	panelFooter: null,
+	currTabName: null,
+	currTabElem: null,
+	content: null,
+
+	init: function() {
+		var cmb = config.messages.backstage;
+		this.area = document.getElementById("backstageArea");
+		this.toolbar = jQuery("#backstageToolbar").empty()[0];
+		this.button = jQuery("#backstageButton").empty()[0];
+		this.button.style.display = "block";
+		var t = cmb.open.text + " " + glyph("bentArrowLeft");
+		this.showButton = createTiddlyButton(this.button,t,cmb.open.tooltip,
+						function(e) {backstage.show(); return false;},null,"backstageShow");
+		t = glyph("bentArrowRight") + " " + cmb.close.text;
+		this.hideButton = createTiddlyButton(this.button,t,cmb.close.tooltip,
+						function(e) {backstage.hide(); return false;},null,"backstageHide");
+		this.cloak = document.getElementById("backstageCloak");
+		this.panel = document.getElementById("backstagePanel");
+		this.panelFooter = createTiddlyElement(this.panel,"div",null,"backstagePanelFooter");
+		this.panelBody = createTiddlyElement(this.panel,"div",null,"backstagePanelBody");
+		this.cloak.onmousedown = function(e) {backstage.switchTab(null);};
+		createTiddlyText(this.toolbar,cmb.prompt);
+		for(t=0; t<config.backstageTasks.length; t++) {
+			var taskName = config.backstageTasks[t];
+			var task = config.tasks[taskName];
+			var handler = task.action ? this.onClickCommand : this.onClickTab;
+			var text = task.text + (task.action ? "" : glyph("downTriangle"));
+			var btn = createTiddlyButton(this.toolbar,text,task.tooltip,handler,"backstageTab");
+			jQuery(btn).addClass(task.action ? "backstageAction" : "backstageTask");
+			btn.setAttribute("task", taskName);
+			}
+		this.content = document.getElementById("contentWrapper");
+		if(config.options.chkBackstage)
+			this.show();
+		else
+			this.hide();
+	},
+
+	isVisible: function() {
+		return this.area ? this.area.style.display == "block" : false;
+	},
+
+	show: function() {
+		this.area.style.display = "block";
+		if(anim && config.options.chkAnimate) {
+			backstage.toolbar.style.left = findWindowWidth() + "px";
+			var p = [{style: "left", start: findWindowWidth(), end: 0, template: "%0px"}];
+			anim.startAnimating(new Morpher(backstage.toolbar,config.animDuration,p));
+		} else {
+			backstage.area.style.left = "0px";
+		}
+		jQuery(this.showButton).hide();
+		jQuery(this.hideButton).show();
+		config.options.chkBackstage = true;
+		saveOption("chkBackstage");
+		jQuery(this.content).addClass("backstageVisible");
+	},
+
+	hide: function() {
+		if(this.currTabElem) {
+			this.switchTab(null);
+		} else {
+			backstage.toolbar.style.left = "0px";
+			if(anim && config.options.chkAnimate) {
+				var p = [{style: "left", start: 0, end: findWindowWidth(), template: "%0px"}];
+				var c = function(element,properties) {backstage.area.style.display = "none";};
+				anim.startAnimating(new Morpher(backstage.toolbar,config.animDuration,p,c));
+			} else {
+				this.area.style.display = "none";
+			}
+			this.showButton.style.display = "block";
+			this.hideButton.style.display = "none";
+			config.options.chkBackstage = false;
+			saveOption("chkBackstage");
+			jQuery(this.content).removeClass("backstageVisible");
+		}
+	},
+
+	onClickCommand: function(e) {
+		var task = config.tasks[this.getAttribute("task")];
+		if(task.action) {
+			backstage.switchTab(null);
+			task.action();
+		}
+		return false;
+	},
+
+	onClickTab: function(e) {
+		backstage.switchTab(this.getAttribute("task"));
+		return false;
+	},
+
+	// Switch to a given tab, or none if null is passed
+	switchTab: function(tabName) {
+		var tabElem = null;
+		var e = this.toolbar.firstChild;
+		while(e) {
+			if(e.getAttribute && e.getAttribute("task") == tabName)
+				tabElem = e;
+			e = e.nextSibling;
+		}
+		if(tabName == backstage.currTabName) {
+			backstage.hidePanel();
+			return;
+		}
+		if(backstage.currTabElem) {
+			jQuery(this.currTabElem).removeClass("backstageSelTab");
+		}
+		if(tabElem && tabName) {
+			backstage.preparePanel();
+			jQuery(tabElem).addClass("backstageSelTab");
+			var task = config.tasks[tabName];
+			wikify(task.content,backstage.panelBody,null,null);
+			backstage.showPanel();
+		} else if(backstage.currTabElem) {
+			backstage.hidePanel();
+		}
+		backstage.currTabName = tabName;
+		backstage.currTabElem = tabElem;
+	},
+
+	isPanelVisible: function() {
+		return backstage.panel ? backstage.panel.style.display == "block" : false;
+	},
+
+	preparePanel: function() {
+		backstage.cloak.style.height = findWindowHeight() + "px";
+		backstage.cloak.style.display = "block";
+		jQuery(backstage.panelBody).empty();
+		return backstage.panelBody;
+	},
+
+	showPanel: function() {
+		backstage.panel.style.display = "block";
+		if(anim && config.options.chkAnimate) {
+			backstage.panel.style.top = (-backstage.panel.offsetHeight) + "px";
+			var p = [{style: "top", start: -backstage.panel.offsetHeight, end: 0, template: "%0px"}];
+			anim.startAnimating(new Morpher(backstage.panel,config.animDuration,p),new Scroller(backstage.panel,false));
+		} else {
+			backstage.panel.style.top = "0px";
+		}
+		return backstage.panelBody;
+	},
+
+	hidePanel: function() {
+		if(backstage.currTabElem)
+			jQuery(backstage.currTabElem).removeClass("backstageSelTab");
+		backstage.currTabElem = null;
+		backstage.currTabName = null;
+		if(anim && config.options.chkAnimate) {
+			var p = [
+				{style: "top", start: 0, end: -(backstage.panel.offsetHeight), template: "%0px"},
+				{style: "display", atEnd: "none"}
+			];
+			var c = function(element,properties) {backstage.cloak.style.display = "none";};
+			anim.startAnimating(new Morpher(backstage.panel,config.animDuration,p,c));
+		} else {
+			jQuery([backstage.panel,backstage.cloak]).hide();
+		}
+	}
+};
+
+config.macros.backstage = {};
+
+config.macros.backstage.handler = function(place,macroName,params)
+{
+	var backstageTask = config.tasks[params[0]];
+	if(backstageTask)
+		createTiddlyButton(place,backstageTask.text,backstageTask.tooltip,function(e) {backstage.switchTab(params[0]); return false;});
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/BasicTypes.js

@@ -0,0 +1,103 @@
+//--
+//-- Augmented methods for the JavaScript Array() object
+//--
+
+// Add indexOf function if browser does not support it
+if(!Array.indexOf) {
+Array.prototype.indexOf = function(item,from)
+{
+	if(!from)
+		from = 0;
+	var i;
+	for(i=from; i<this.length; i++) {
+		if(this[i] === item)
+			return i;
+	}
+	return -1;
+};}
+
+// Find an entry in a given field of the members of an array
+Array.prototype.findByField = function(field,value)
+{
+	var t;
+	for(t=0; t<this.length; t++) {
+		if(this[t][field] === value)
+			return t;
+	}
+	return null;
+};
+
+// Return whether an entry exists in an array
+Array.prototype.contains = function(item)
+{
+	return this.indexOf(item) != -1;
+};
+
+// Adds, removes or toggles a particular value within an array
+//  value - value to add
+//  mode - +1 to add value, -1 to remove value, 0 to toggle it
+Array.prototype.setItem = function(value,mode)
+{
+	var p = this.indexOf(value);
+	if(mode == 0)
+		mode = (p == -1) ? +1 : -1;
+	if(mode == +1) {
+		if(p == -1)
+			this.push(value);
+	} else if(mode == -1) {
+		if(p != -1)
+			this.splice(p,1);
+	}
+};
+
+// Return whether one of a list of values exists in an array
+Array.prototype.containsAny = function(items)
+{
+	var i;
+	for(i=0; i<items.length; i++) {
+		if(this.indexOf(items[i]) != -1)
+			return true;
+	}
+	return false;
+};
+
+// Return whether all of a list of values exists in an array
+Array.prototype.containsAll = function(items)
+{
+	var i;
+	for(i = 0; i<items.length; i++) {
+		if(this.indexOf(items[i]) == -1)
+			return false;
+	}
+	return true;
+};
+
+// Push a new value into an array only if it is not already present in the array. If the optional unique parameter is false, it reverts to a normal push
+Array.prototype.pushUnique = function(item,unique)
+{
+	if(unique === false) {
+		this.push(item);
+	} else {
+		if(this.indexOf(item) == -1)
+			this.push(item);
+	}
+};
+
+Array.prototype.remove = function(item)
+{
+	var p = this.indexOf(item);
+	if(p != -1)
+		this.splice(p,1);
+};
+
+if(!Array.prototype.map) {
+Array.prototype.map = function(fn,thisObj)
+{
+	var scope = thisObj || window;
+	var i,j,a = [];
+	for(i=0, j=this.length; i < j; ++i) {
+		a.push(fn.call(scope,this[i],i,this));
+	}
+	return a;
+};}
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Commands.js

@@ -0,0 +1,178 @@
+//--
+//-- Menu and toolbar commands
+//--
+
+config.commands.closeTiddler.handler = function(event,src,title)
+{
+	if(story.isDirty(title) && !readOnly) {
+		if(!confirm(config.commands.cancelTiddler.warning.format([title])))
+			return false;
+	}
+	story.setDirty(title,false);
+	story.closeTiddler(title,true);
+	return false;
+};
+
+config.commands.closeOthers.handler = function(event,src,title)
+{
+	story.closeAllTiddlers(title);
+	return false;
+};
+
+config.commands.editTiddler.handler = function(event,src,title)
+{
+	clearMessage();
+	var tiddlerElem = story.getTiddler(title);
+	var fields = tiddlerElem.getAttribute("tiddlyFields");
+	story.displayTiddler(null,title,DEFAULT_EDIT_TEMPLATE,false,null,fields);
+	var e = story.getTiddlerField(title,config.options.txtEditorFocus||"text");
+	if(e) {
+		setCaretPosition(e,0);
+	}
+	return false;
+};
+
+config.commands.saveTiddler.handler = function(event,src,title)
+{
+	var newTitle = story.saveTiddler(title,event.shiftKey);
+	if(newTitle)
+		story.displayTiddler(null,newTitle);
+	return false;
+};
+
+config.commands.cancelTiddler.handler = function(event,src,title)
+{
+	if(story.hasChanges(title) && !readOnly) {
+		if(!confirm(this.warning.format([title])))
+			return false;
+	}
+	story.setDirty(title,false);
+	story.displayTiddler(null,title);
+	return false;
+};
+
+config.commands.deleteTiddler.handler = function(event,src,title)
+{
+	var deleteIt = true;
+	if(config.options.chkConfirmDelete)
+		deleteIt = confirm(this.warning.format([title]));
+	if(deleteIt) {
+		store.removeTiddler(title);
+		story.closeTiddler(title,true);
+		autoSaveChanges();
+	}
+	return false;
+};
+
+config.commands.permalink.handler = function(event,src,title)
+{
+	var t = encodeURIComponent(String.encodeTiddlyLink(title));
+	if(window.location.hash != t)
+		window.location.hash = t;
+	return false;
+};
+
+config.commands.references.handlePopup = function(popup,title)
+{
+	var references = store.getReferringTiddlers(title);
+	var c = false;
+	var r;
+	for(r=0; r<references.length; r++) {
+		if(references[r].title != title && !references[r].isTagged("excludeLists")) {
+			createTiddlyLink(createTiddlyElement(popup,"li"),references[r].title,true);
+			c = true;
+		}
+	}
+	if(!c)
+		createTiddlyElement(popup,"li",null,"disabled",this.popupNone);
+};
+
+config.commands.jump.handlePopup = function(popup,title)
+{
+	story.forEachTiddler(function(title,element) {
+		createTiddlyLink(createTiddlyElement(popup,"li"),title,true,null,false,null,true);
+		});
+};
+
+config.commands.syncing.handlePopup = function(popup,title)
+{
+	var me = config.commands.syncing;
+	var tiddler = store.fetchTiddler(title);
+	if(!tiddler)
+		return;
+	var serverType = tiddler.getServerType();
+	var serverHost = tiddler.fields["server.host"];
+	var serverWorkspace = tiddler.fields["server.workspace"];
+	if(!serverWorkspace)
+		serverWorkspace = "";
+	if(serverType) {
+		var e = createTiddlyElement(popup,"li",null,"popupMessage");
+		e.innerHTML = me.currentlySyncing.format([serverType,serverHost,serverWorkspace]);
+	} else {
+		createTiddlyElement(popup,"li",null,"popupMessage",me.notCurrentlySyncing);
+	}
+	if(serverType) {
+		createTiddlyElement(createTiddlyElement(popup,"li",null,"listBreak"),"div");
+		var btn = createTiddlyButton(createTiddlyElement(popup,"li"),this.captionUnSync,null,me.onChooseServer);
+		btn.setAttribute("tiddler",title);
+		btn.setAttribute("server.type","");
+	}
+	createTiddlyElement(createTiddlyElement(popup,"li",null,"listBreak"),"div");
+	createTiddlyElement(popup,"li",null,"popupMessage",me.chooseServer);
+	var feeds = store.getTaggedTiddlers("systemServer","title");
+	var t;
+	for(t=0; t<feeds.length; t++) {
+		var f = feeds[t];
+		var feedServerType = store.getTiddlerSlice(f.title,"Type");
+		if(!feedServerType)
+			feedServerType = "file";
+		var feedServerHost = store.getTiddlerSlice(f.title,"URL");
+		if(!feedServerHost)
+			feedServerHost = "";
+		var feedServerWorkspace = store.getTiddlerSlice(f.title,"Workspace");
+		if(!feedServerWorkspace)
+			feedServerWorkspace = "";
+		var caption = f.title;
+		if(serverType == feedServerType && serverHost == feedServerHost && serverWorkspace == feedServerWorkspace) {
+			caption = me.currServerMarker + caption;
+		} else {
+			caption = me.notCurrServerMarker + caption;
+		}
+		btn = createTiddlyButton(createTiddlyElement(popup,"li"),caption,null,me.onChooseServer);
+		btn.setAttribute("tiddler",title);
+		btn.setAttribute("server.type",feedServerType);
+		btn.setAttribute("server.host",feedServerHost);
+		btn.setAttribute("server.workspace",feedServerWorkspace);
+	}
+};
+
+config.commands.syncing.onChooseServer = function(e)
+{
+	var tiddler = this.getAttribute("tiddler");
+	var serverType = this.getAttribute("server.type");
+	if(serverType) {
+		store.addTiddlerFields(tiddler,{
+			"server.type": serverType,
+			"server.host": this.getAttribute("server.host"),
+			"server.workspace": this.getAttribute("server.workspace")
+			});
+	} else {
+		store.setValue(tiddler,"server",null);
+	}
+	return false;
+};
+
+config.commands.fields.handlePopup = function(popup,title)
+{
+	var tiddler = store.fetchTiddler(title);
+	if(!tiddler)
+		return;
+	var items = [];
+	store.forEachField(tiddler,function(tiddler,fieldName,value){items.push({field:fieldName,value:value});},true);
+	items.sort(function(a,b) {return a.field < b.field ? -1 : (a.field == b.field ? 0 : +1);});
+	if(items.length > 0)
+		ListView.create(popup,items,this.listViewTemplate);
+	else
+		createTiddlyElement(popup,"div",null,null,this.emptyText);
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Config.js

@@ -0,0 +1,227 @@
+//--
+//-- Configuration repository
+//--
+
+// Miscellaneous options
+var config = {
+	numRssItems: 20, // Number of items in the RSS feed
+	animDuration: 400, // Duration of UI animations in milliseconds
+	cascadeFast: 20, // Speed for cascade animations (higher == slower)
+	cascadeSlow: 60, // Speed for EasterEgg cascade animations
+	cascadeDepth: 5, // Depth of cascade animation
+	locale: "en" // W3C language tag
+};
+
+// Hashmap of alternative parsers for the wikifier
+config.parsers = {};
+
+// Adaptors
+config.adaptors = {};
+config.defaultAdaptor = null;
+
+// Backstage tasks
+config.tasks = {};
+
+// Annotations
+config.annotations = {};
+
+// Custom fields to be automatically added to new tiddlers
+config.defaultCustomFields = {};
+
+// Messages
+config.messages = {
+	messageClose: {},
+	dates: {},
+	tiddlerPopup: {}
+};
+
+// Options that can be set in the options panel and/or cookies
+config.options = {
+	chkRegExpSearch: false,
+	chkCaseSensitiveSearch: false,
+	chkIncrementalSearch: true,
+	chkAnimate: true,
+	chkSaveBackups: true,
+	chkAutoSave: false,
+	chkGenerateAnRssFeed: false,
+	chkSaveEmptyTemplate: false,
+	chkOpenInNewWindow: true,
+	chkToggleLinks: false,
+	chkHttpReadOnly: true,
+	chkForceMinorUpdate: false,
+	chkConfirmDelete: true,
+	chkInsertTabs: false,
+	chkUsePreForStorage: true, // Whether to use <pre> format for storage
+	chkDisplayInstrumentation: false,
+	txtBackupFolder: "",
+	txtEditorFocus: "text",
+	txtMainTab: "tabTimeline",
+	txtMoreTab: "moreTabAll",
+	txtMaxEditRows: "30",
+	txtFileSystemCharSet: "UTF-8",
+	txtTheme: ""
+	};
+config.optionsDesc = {};
+
+//# config.optionSource["chkAnimate"] can be:
+//# 	cookie: the option gets stored in a cookie, with the default value coming from SystemSettings
+//#		volatile: the option isn't persisted at all, and reverts to the default specified in SystemSettings when the document is reloaded
+//#		setting: the option is stored in the SystemSettings tiddler
+//#	The default is "setting"
+config.optionsSource = {};
+
+// Default tiddler templates
+var DEFAULT_VIEW_TEMPLATE = 1;
+var DEFAULT_EDIT_TEMPLATE = 2;
+config.tiddlerTemplates = {
+	1: "ViewTemplate",
+	2: "EditTemplate"
+};
+
+// More messages (rather a legacy layout that should not really be like this)
+config.views = {
+	wikified: {
+		tag: {}
+	},
+	editor: {
+		tagChooser: {}
+	}
+};
+
+// Backstage tasks
+config.backstageTasks = ["save","sync","importTask","tweak","upgrade","plugins"];
+
+// Extensions
+config.extensions = {};
+
+// Macros; each has a 'handler' member that is inserted later
+config.macros = {
+	today: {},
+	version: {},
+	search: {sizeTextbox: 15},
+	tiddler: {},
+	tag: {},
+	tags: {},
+	tagging: {},
+	timeline: {},
+	allTags: {},
+	list: {
+		all: {},
+		missing: {},
+		orphans: {},
+		shadowed: {},
+		touched: {},
+		filter: {}
+	},
+	closeAll: {},
+	permaview: {},
+	saveChanges: {},
+	slider: {},
+	option: {},
+	options: {},
+	newTiddler: {},
+	newJournal: {},
+	tabs: {},
+	gradient: {},
+	message: {},
+	view: {defaultView: "text"},
+	edit: {},
+	tagChooser: {},
+	toolbar: {},
+	plugins: {},
+	refreshDisplay: {},
+	importTiddlers: {},
+	upgrade: {
+		source: "http://tiddlywiki-releases.tiddlyspace.com/upgrade",
+		backupExtension: "pre.core.upgrade"
+	},
+	sync: {},
+	annotations: {}
+};
+
+// Commands supported by the toolbar macro
+config.commands = {
+	closeTiddler: {},
+	closeOthers: {},
+	editTiddler: {},
+	saveTiddler: {hideReadOnly: true},
+	cancelTiddler: {},
+	deleteTiddler: {hideReadOnly: true},
+	permalink: {},
+	references: {type: "popup"},
+	jump: {type: "popup"},
+	syncing: {type: "popup"},
+	fields: {type: "popup"}
+};
+
+// Control of macro parameter evaluation
+config.evaluateMacroParameters = "all";
+
+// Basic regular expressions
+config.textPrimitives = {
+	upperLetter: "[A-Z\u00c0-\u00de\u0150\u0170]",
+	lowerLetter: "[a-z0-9_\\-\u00df-\u00ff\u0151\u0171]",
+	anyLetter:   "[A-Za-z0-9_\\-\u00c0-\u00de\u00df-\u00ff\u0150\u0170\u0151\u0171]",
+	anyLetterStrict: "[A-Za-z0-9\u00c0-\u00de\u00df-\u00ff\u0150\u0170\u0151\u0171]"
+};
+if(!((new RegExp("[\u0150\u0170]","g")).test("\u0150"))) {
+	config.textPrimitives = {
+		upperLetter: "[A-Z\u00c0-\u00de]",
+		lowerLetter: "[a-z0-9_\\-\u00df-\u00ff]",
+		anyLetter:   "[A-Za-z0-9_\\-\u00c0-\u00de\u00df-\u00ff]",
+		anyLetterStrict: "[A-Za-z0-9\u00c0-\u00de\u00df-\u00ff]"
+	};
+}
+config.textPrimitives.sliceSeparator = "::";
+config.textPrimitives.sectionSeparator = "##";
+config.textPrimitives.urlPattern = "(?:file|http|https|mailto|ftp|irc|news|data):[^\\s'\"]+(?:/|\\b)";
+config.textPrimitives.unWikiLink = "~";
+config.textPrimitives.wikiLink = "(?:(?:" + config.textPrimitives.upperLetter + "+" +
+	config.textPrimitives.lowerLetter + "+" +
+	config.textPrimitives.upperLetter +
+	config.textPrimitives.anyLetter + "*)|(?:" +
+	config.textPrimitives.upperLetter + "{2,}" +
+	config.textPrimitives.lowerLetter + "+))";
+
+config.textPrimitives.cssLookahead = "(?:(" + config.textPrimitives.anyLetter + "+)\\(([^\\)\\|\\n]+)(?:\\):))|(?:(" + config.textPrimitives.anyLetter + "+):([^;\\|\\n]+);)";
+config.textPrimitives.cssLookaheadRegExp = new RegExp(config.textPrimitives.cssLookahead,"mg");
+
+config.textPrimitives.brackettedLink = "\\[\\[([^\\]]+)\\]\\]";
+config.textPrimitives.titledBrackettedLink = "\\[\\[([^\\[\\]\\|]+)\\|([^\\[\\]\\|]+)\\]\\]";
+config.textPrimitives.tiddlerForcedLinkRegExp = new RegExp("(?:" + config.textPrimitives.titledBrackettedLink + ")|(?:" +
+	config.textPrimitives.brackettedLink + ")|(?:" +
+	config.textPrimitives.urlPattern + ")","mg");
+config.textPrimitives.tiddlerAnyLinkRegExp = new RegExp("("+ config.textPrimitives.wikiLink + ")|(?:" +
+	config.textPrimitives.titledBrackettedLink + ")|(?:" +
+	config.textPrimitives.brackettedLink + ")|(?:" +
+	config.textPrimitives.urlPattern + ")","mg");
+
+config.glyphs = {
+	currBrowser: null,
+	browsers: [],
+	codes: {}
+};
+
+//--
+//-- Shadow tiddlers
+//--
+
+config.shadowTiddlers = {
+	StyleSheet: "",
+	MarkupPreHead: "",
+	MarkupPostHead: "",
+	MarkupPreBody: "",
+	MarkupPostBody: "",
+	TabTimeline: '<<timeline>>',
+	TabAll: '<<list all>>',
+	TabTags: '<<allTags excludeLists>>',
+	TabMoreMissing: '<<list missing>>',
+	TabMoreOrphans: '<<list orphans>>',
+	TabMoreShadowed: '<<list shadowed>>',
+	AdvancedOptions: '<<options>>',
+	PluginManager: '<<plugins>>',
+	SystemSettings: '',
+	ToolbarCommands: '|~ViewToolbar|closeTiddler closeOthers +editTiddler > fields syncing permalink references jump|\n|~EditToolbar|+saveTiddler -cancelTiddler deleteTiddler|',
+	WindowTitle: '<<tiddler SiteTitle>> - <<tiddler SiteSubtitle>>'
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/ConfigBrowser.js

@@ -0,0 +1,30 @@
+// Browser detection... In a very few places, there's nothing else for it but to know what browser we're using.
+config.userAgent = navigator.userAgent.toLowerCase();
+config.browser = {
+	isIE: config.userAgent.indexOf("msie") != -1 && config.userAgent.indexOf("opera") == -1,
+	isGecko: navigator.product == "Gecko" && config.userAgent.indexOf("WebKit") == -1,
+	ieVersion: /MSIE (\d.\d)/i.exec(config.userAgent), // config.browser.ieVersion[1], if it exists, will be the IE version string, eg "6.0"
+	isSafari: config.userAgent.indexOf("applewebkit") != -1,
+	isBadSafari: !((new RegExp("[\u0150\u0170]","g")).test("\u0150")),
+	firefoxDate: /gecko\/(\d{8})/i.exec(config.userAgent), // config.browser.firefoxDate[1], if it exists, will be Firefox release date as "YYYYMMDD"
+	isOpera: config.userAgent.indexOf("opera") != -1,
+	isChrome: config.userAgent.indexOf('chrome') > -1,
+	isLinux: config.userAgent.indexOf("linux") != -1,
+	isUnix: config.userAgent.indexOf("x11") != -1,
+	isMac: config.userAgent.indexOf("mac") != -1,
+	isWindows: config.userAgent.indexOf("win") != -1
+};
+
+merge(config.glyphs,{
+	browsers: [
+		function() {return config.browser.isIE;},
+		function() {return true;}
+		],
+	codes: {
+		downTriangle: ["\u25BC","\u25BE"],
+		downArrow: ["\u2193","\u2193"],
+		bentArrowLeft: ["\u2190","\u21A9"],
+		bentArrowRight: ["\u2192","\u21AA"]
+	}
+});
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Crypto.js

@@ -0,0 +1,143 @@
+//--
+//-- Crypto functions and associated conversion routines
+//--
+
+// Crypto 'namespace'
+function Crypto() {}
+
+// Convert a string to an array of big-endian 32-bit words
+Crypto.strToBe32s = function(str)
+{
+	var be=[];
+	var len=Math.floor(str.length/4);
+	var i, j;
+	for(i=0, j=0; i<len; i++, j+=4) {
+		be[i]=((str.charCodeAt(j)&0xff) << 24)|((str.charCodeAt(j+1)&0xff) << 16)|((str.charCodeAt(j+2)&0xff) << 8)|(str.charCodeAt(j+3)&0xff);
+	}
+	while(j<str.length) {
+		be[j>>2] |= (str.charCodeAt(j)&0xff)<<(24-(j*8)%32);
+		j++;
+	}
+	return be;
+};
+
+// Convert an array of big-endian 32-bit words to a string
+Crypto.be32sToStr = function(be)
+{
+	var str='';
+	for(var i=0;i<be.length*32;i+=8) {
+		str += String.fromCharCode((be[i>>5]>>>(24-i%32)) & 0xff);
+	}
+	return str;
+};
+
+// Convert an array of big-endian 32-bit words to a hex string
+Crypto.be32sToHex = function(be)
+{
+	var hex='0123456789ABCDEF';
+	var str='';
+	for(var i=0;i<be.length*4;i++) {
+		str += hex.charAt((be[i>>2]>>((3-i%4)*8+4))&0xF) + hex.charAt((be[i>>2]>>((3-i%4)*8))&0xF);
+	}
+	return str;
+};
+
+// Return, in hex, the SHA-1 hash of a string
+Crypto.hexSha1Str = function(str)
+{
+	return Crypto.be32sToHex(Crypto.sha1Str(str));
+};
+
+// Return the SHA-1 hash of a string
+Crypto.sha1Str = function(str)
+{
+	return Crypto.sha1(Crypto.strToBe32s(str),str.length);
+};
+
+// Calculate the SHA-1 hash of an array of blen bytes of big-endian 32-bit words
+Crypto.sha1 = function(x,blen)
+{
+	// Add 32-bit integers, wrapping at 32 bits
+	//# Uses 16-bit operations internally to work around bugs in some JavaScript interpreters.
+	function add32(a,b)
+	{
+		var lsw=(a&0xFFFF)+(b&0xFFFF);
+		var msw=(a>>16)+(b>>16)+(lsw>>16);
+		return (msw<<16)|(lsw&0xFFFF);
+	}
+	//# Cryptographic round helper function. Add five 32-bit integers, wrapping at 32 bits, second parameter is rotated left 5 bits before the addition
+	//# Uses 16-bit operations internally to work around bugs in some JavaScript interpreters.
+	function AA(a,b,c,d,e)
+	{
+		b=(b>>>27)|(b<<5);
+		var lsw=(a&0xFFFF)+(b&0xFFFF)+(c&0xFFFF)+(d&0xFFFF)+(e&0xFFFF);
+		var msw=(a>>16)+(b>>16)+(c>>16)+(d>>16)+(e>>16)+(lsw>>16);
+		return (msw<<16)|(lsw&0xFFFF);
+	}
+	//# Cryptographic round helper function.
+	function RR(w,j)
+	{
+		var n=w[j-3]^w[j-8]^w[j-14]^w[j-16];
+		return (n>>>31)|(n<<1);
+	}
+
+	var len=blen*8;
+	//# Append padding so length in bits is 448 mod 512
+	x[len>>5] |= 0x80 << (24-len%32);
+	//# Append length
+	x[((len+64>>9)<<4)+15]=len;
+	var w=new Array(80);
+
+	var k1=0x5A827999;
+	var k2=0x6ED9EBA1;
+	var k3=0x8F1BBCDC;
+	var k4=0xCA62C1D6;
+
+	var h0=0x67452301;
+	var h1=0xEFCDAB89;
+	var h2=0x98BADCFE;
+	var h3=0x10325476;
+	var h4=0xC3D2E1F0;
+
+	for(var i=0;i<x.length;i+=16) {
+		var j=0;
+		var t;
+		var a=h0;
+		var b=h1;
+		var c=h2;
+		var d=h3;
+		var e=h4;
+		while(j<16) {
+			w[j]=x[i+j];
+			t=AA(e,a,d^(b&(c^d)),w[j],k1);
+			e=d; d=c; c=(b>>>2)|(b<<30); b=a; a=t; j++;
+		}
+		while(j<20) {
+			w[j]=RR(w,j);
+			t=AA(e,a,d^(b&(c^d)),w[j],k1);
+			e=d; d=c; c=(b>>>2)|(b<<30); b=a; a=t; j++;
+		}
+		while(j<40) {
+			w[j]=RR(w,j);
+			t=AA(e,a,b^c^d,w[j],k2);
+			e=d; d=c; c=(b>>>2)|(b<<30); b=a; a=t; j++;
+		}
+		while(j<60) {
+			w[j]=RR(w,j);
+			t=AA(e,a,(b&c)|(d&(b|c)),w[j],k3);
+			e=d; d=c; c=(b>>>2)|(b<<30); b=a; a=t; j++;
+		}
+		while(j<80) {
+			w[j]=RR(w,j);
+			t=AA(e,a,b^c^d,w[j],k4);
+			e=d; d=c; c=(b>>>2)|(b<<30); b=a; a=t; j++;
+		}
+		h0=add32(h0,a);
+		h1=add32(h1,b);
+		h2=add32(h2,c);
+		h3=add32(h3,d);
+		h4=add32(h4,e);
+	}
+	return [h0,h1,h2,h3,h4];
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Dates.js

@@ -0,0 +1,119 @@
+//--
+//-- Augmented methods for the JavaScript Date() object
+//--
+
+// Substitute date components into a string
+Date.prototype.formatString = function(template)
+{
+	var t = template.replace(/0hh12/g,String.zeroPad(this.getHours12(),2));
+	t = t.replace(/hh12/g,this.getHours12());
+	t = t.replace(/0hh/g,String.zeroPad(this.getHours(),2));
+	t = t.replace(/hh/g,this.getHours());
+	t = t.replace(/mmm/g,config.messages.dates.shortMonths[this.getMonth()]);
+	t = t.replace(/0mm/g,String.zeroPad(this.getMinutes(),2));
+	t = t.replace(/mm/g,this.getMinutes());
+	t = t.replace(/0ss/g,String.zeroPad(this.getSeconds(),2));
+	t = t.replace(/ss/g,this.getSeconds());
+	t = t.replace(/[ap]m/g,this.getAmPm().toLowerCase());
+	t = t.replace(/[AP]M/g,this.getAmPm().toUpperCase());
+	t = t.replace(/wYYYY/g,this.getYearForWeekNo());
+	t = t.replace(/wYY/g,String.zeroPad(this.getYearForWeekNo()-2000,2));
+	t = t.replace(/YYYY/g,this.getFullYear());
+	t = t.replace(/YY/g,String.zeroPad(this.getFullYear()-2000,2));
+	t = t.replace(/MMM/g,config.messages.dates.months[this.getMonth()]);
+	t = t.replace(/0MM/g,String.zeroPad(this.getMonth()+1,2));
+	t = t.replace(/MM/g,this.getMonth()+1);
+	t = t.replace(/0WW/g,String.zeroPad(this.getWeek(),2));
+	t = t.replace(/WW/g,this.getWeek());
+	t = t.replace(/DDD/g,config.messages.dates.days[this.getDay()]);
+	t = t.replace(/ddd/g,config.messages.dates.shortDays[this.getDay()]);
+	t = t.replace(/0DD/g,String.zeroPad(this.getDate(),2));
+	t = t.replace(/DDth/g,this.getDate()+this.daySuffix());
+	t = t.replace(/DD/g,this.getDate());
+	var tz = this.getTimezoneOffset();
+	var atz = Math.abs(tz);
+	t = t.replace(/TZD/g,(tz < 0 ? '+' : '-') + String.zeroPad(Math.floor(atz / 60),2) + ':' + String.zeroPad(atz % 60,2));
+	t = t.replace(/\\/g,"");
+	return t;
+};
+
+Date.prototype.getWeek = function()
+{
+	var dt = new Date(this.getTime());
+	var d = dt.getDay();
+	if(d==0) d=7;// JavaScript Sun=0, ISO Sun=7
+	dt.setTime(dt.getTime()+(4-d)*86400000);// shift day to Thurs of same week to calculate weekNo
+	var n = Math.floor((dt.getTime()-new Date(dt.getFullYear(),0,1)+3600000)/86400000);
+	return Math.floor(n/7)+1;
+};
+
+Date.prototype.getYearForWeekNo = function()
+{
+	var dt = new Date(this.getTime());
+	var d = dt.getDay();
+	if(d==0) d=7;// JavaScript Sun=0, ISO Sun=7
+	dt.setTime(dt.getTime()+(4-d)*86400000);// shift day to Thurs of same week
+	return dt.getFullYear();
+};
+
+Date.prototype.getHours12 = function()
+{
+	var h = this.getHours();
+	return h > 12 ? h-12 : ( h > 0 ? h : 12 );
+};
+
+Date.prototype.getAmPm = function()
+{
+	return this.getHours() >= 12 ? config.messages.dates.pm : config.messages.dates.am;
+};
+
+Date.prototype.daySuffix = function()
+{
+	return config.messages.dates.daySuffixes[this.getDate()-1];
+};
+
+// Convert a date to local YYYYMMDDHHMM string format
+Date.prototype.convertToLocalYYYYMMDDHHMM = function()
+{
+	return this.getFullYear() + String.zeroPad(this.getMonth()+1,2) + String.zeroPad(this.getDate(),2) + String.zeroPad(this.getHours(),2) + String.zeroPad(this.getMinutes(),2);
+};
+
+// Convert a date to UTC YYYYMMDDHHMM string format
+Date.prototype.convertToYYYYMMDDHHMM = function()
+{
+	return this.getUTCFullYear() + String.zeroPad(this.getUTCMonth()+1,2) + String.zeroPad(this.getUTCDate(),2) + String.zeroPad(this.getUTCHours(),2) + String.zeroPad(this.getUTCMinutes(),2);
+};
+
+// Convert a date to UTC YYYYMMDD.HHMMSSMMM string format
+Date.prototype.convertToYYYYMMDDHHMMSSMMM = function()
+{
+	return this.getUTCFullYear() + String.zeroPad(this.getUTCMonth()+1,2) + String.zeroPad(this.getUTCDate(),2) + "." + String.zeroPad(this.getUTCHours(),2) + String.zeroPad(this.getUTCMinutes(),2) + String.zeroPad(this.getUTCSeconds(),2) + String.zeroPad(this.getUTCMilliseconds(),3) +"0";
+};
+
+// Static method to create a date from a UTC YYYYMMDDHHMM format string
+Date.convertFromYYYYMMDDHHMM = function(d)
+{
+	d = d?d.replace(/[^0-9]/g, ""):"";
+	return Date.convertFromYYYYMMDDHHMMSSMMM(d.substr(0,12));
+};
+
+// Static method to create a date from a UTC YYYYMMDDHHMMSS format string
+Date.convertFromYYYYMMDDHHMMSS = function(d)
+{
+	d = d?d.replace(/[^0-9]/g, ""):"";
+	return Date.convertFromYYYYMMDDHHMMSSMMM(d.substr(0,14));
+};
+
+// Static method to create a date from a UTC YYYYMMDDHHMMSSMMM format string
+Date.convertFromYYYYMMDDHHMMSSMMM = function(d)
+{
+	d = d ? d.replace(/[^0-9]/g, "") : "";
+	return new Date(Date.UTC(parseInt(d.substr(0,4),10),
+			parseInt(d.substr(4,2),10)-1,
+			parseInt(d.substr(6,2),10),
+			parseInt(d.substr(8,2)||"00",10),
+			parseInt(d.substr(10,2)||"00",10),
+			parseInt(d.substr(12,2)||"00",10),
+			parseInt(d.substr(14,3)||"000",10)));
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Dom.js

@@ -0,0 +1,264 @@
+//--
+//-- DOM utilities - many derived from www.quirksmode.org
+//--
+
+function drawGradient(place,horiz,locolors,hicolors)
+{
+	if(!hicolors)
+		hicolors = locolors;
+	var t;
+	for(t=0; t<= 100; t+=2) {
+		var bar = document.createElement("div");
+		place.appendChild(bar);
+		bar.style.position = "absolute";
+		bar.style.left = horiz ? t + "%" : 0;
+		bar.style.top = horiz ? 0 : t + "%";
+		bar.style.width = horiz ? (101-t) + "%" : "100%";
+		bar.style.height = horiz ? "100%" : (101-t) + "%";
+		bar.style.zIndex = -1;
+		var p = t/100*(locolors.length-1);
+		var hc = hicolors[Math.floor(p)];
+		if(typeof hc == "string")
+			hc = new RGB(hc);
+		var lc = locolors[Math.ceil(p)];
+		if(typeof lc == "string")
+			lc = new RGB(lc);
+		bar.style.backgroundColor = hc.mix(lc,p-Math.floor(p)).toString();
+	}
+}
+
+//# Add an event handler
+//# Thanks to John Resig, via QuirksMode
+function addEvent(obj,type,fn)
+{
+	if(obj.attachEvent) {
+		obj["e"+type+fn] = fn;
+		obj[type+fn] = function(){obj["e"+type+fn](window.event);};
+		obj.attachEvent("on"+type,obj[type+fn]);
+	} else {
+		obj.addEventListener(type,fn,false);
+	}
+}
+
+//# Remove an event handler
+//# Thanks to John Resig, via QuirksMode
+function removeEvent(obj,type,fn)
+{
+	if(obj.detachEvent) {
+		obj.detachEvent("on"+type,obj[type+fn]);
+		obj[type+fn] = null;
+	} else {
+		obj.removeEventListener(type,fn,false);
+	}
+}
+
+// Find the closest relative with a given property value (property defaults to tagName, relative defaults to parentNode)
+function findRelated(e,value,name,relative)
+{
+	name = name || "tagName";
+	relative = relative || "parentNode";
+	if(name == "className") {
+		while(e && !jQuery(e).hasClass(value)) {
+			e = e[relative];
+		}
+	} else {
+		while(e && e[name] != value) {
+			e = e[relative];
+		}
+	}
+	return e;
+}
+
+// Get the scroll position for window.scrollTo necessary to scroll a given element into view
+function ensureVisible(e)
+{
+	var posTop = findPosY(e);
+	var posBot = posTop + e.offsetHeight;
+	var winTop = findScrollY();
+	var winHeight = findWindowHeight();
+	var winBot = winTop + winHeight;
+	if(posTop < winTop) {
+		return posTop;
+	} else if(posBot > winBot) {
+		if(e.offsetHeight < winHeight)
+			return posTop - (winHeight - e.offsetHeight);
+		else
+			return posTop;
+	} else {
+		return winTop;
+	}
+}
+
+// Get the current width of the display window
+function findWindowWidth()
+{
+	return window.innerWidth || document.documentElement.clientWidth;
+}
+
+// Get the current height of the display window
+function findWindowHeight()
+{
+	return window.innerHeight || document.documentElement.clientHeight;
+}
+
+// Get the current horizontal page scroll position
+function findScrollX()
+{
+	return window.scrollX || document.documentElement.scrollLeft;
+}
+
+// Get the current vertical page scroll position
+function findScrollY()
+{
+	return window.scrollY || document.documentElement.scrollTop;
+}
+
+function findPosX(obj)
+{
+	var curleft = 0;
+	while(obj.offsetParent) {
+		curleft += obj.offsetLeft;
+		obj = obj.offsetParent;
+	}
+	return curleft;
+}
+
+function findPosY(obj)
+{
+	var curtop = 0;
+	while(obj.offsetParent) {
+		curtop += obj.offsetTop;
+		obj = obj.offsetParent;
+	}
+	return curtop;
+}
+
+// Blur a particular element
+function blurElement(e)
+{
+	if(e && e.focus && e.blur) {
+		e.focus();
+		e.blur();
+	}
+}
+
+// Create a non-breaking space
+function insertSpacer(place)
+{
+	var e = document.createTextNode(String.fromCharCode(160));
+	if(place)
+		place.appendChild(e);
+	return e;
+}
+
+// Replace the current selection of a textarea or text input and scroll it into view
+function replaceSelection(e,text)
+{
+	if(e.setSelectionRange) {
+		var oldpos = e.selectionStart;
+		var isRange = e.selectionEnd > e.selectionStart;
+		e.value = e.value.substr(0,e.selectionStart) + text + e.value.substr(e.selectionEnd);
+		e.setSelectionRange(isRange ? oldpos : oldpos + text.length,oldpos + text.length);
+		var linecount = e.value.split("\n").length;
+		var thisline = e.value.substr(0,e.selectionStart).split("\n").length-1;
+		e.scrollTop = Math.floor((thisline - e.rows / 2) * e.scrollHeight / linecount);
+	} else if(document.selection) {
+		var range = document.selection.createRange();
+		if(range.parentElement() == e) {
+			var isCollapsed = range.text == "";
+			range.text = text;
+			if(!isCollapsed) {
+				range.moveStart("character", -text.length);
+				range.select();
+			}
+		}
+	}
+}
+
+// Set the caret position in a text area
+function setCaretPosition(e,pos)
+{
+	if(e.selectionStart || e.selectionStart == '0') {
+		e.selectionStart = pos;
+		e.selectionEnd = pos;
+		e.focus();
+	} else if(document.selection) {
+		// IE support
+		e.focus ();
+		var sel = document.selection.createRange();
+		sel.moveStart('character', -e.value.length);
+		sel.moveStart('character',pos);
+		sel.moveEnd('character',0);
+		sel.select();
+	}
+}
+
+// Returns the text of the given (text) node, possibly merging subsequent text nodes
+function getNodeText(e)
+{
+	var t = "";
+	while(e && e.nodeName == "#text") {
+		t += e.nodeValue;
+		e = e.nextSibling;
+	}
+	return t;
+}
+
+// Returns true if the element e has a given ancestor element
+function isDescendant(e,ancestor)
+{
+	while(e) {
+		if(e === ancestor)
+			return true;
+		e = e.parentNode;
+	}
+	return false;
+}
+
+
+// deprecate the following...
+
+// Prevent an event from bubbling
+function stopEvent(e)
+{
+	var ev = e || window.event;
+	ev.cancelBubble = true;
+	if(ev.stopPropagation) ev.stopPropagation();
+	return false;
+}
+
+// Remove any event handlers or non-primitve custom attributes
+function scrubNode(e)
+{
+	if(!config.browser.isIE)
+		return;
+	var att = e.attributes;
+	if(att) {
+		var t;
+		for(t=0; t<att.length; t++) {
+			var n = att[t].name;
+			if(n !== "style" && (typeof e[n] === "function" || (typeof e[n] === "object" && e[n] != null))) {
+				try {
+					e[n] = null;
+				} catch(ex) {
+				}
+			}
+		}
+	}
+	var c = e.firstChild;
+	while(c) {
+		scrubNode(c);
+		c = c.nextSibling;
+	}
+}
+
+function setStylesheet(s,id,doc)
+{
+	jQuery.twStylesheet(s,{id:id,doc:doc});
+}
+
+function removeStyleSheet(id)
+{
+	jQuery.twStylesheet.remove({id:id});
+}
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/FileAdaptor.js

@@ -0,0 +1,185 @@
+//--
+//-- Server adaptor for talking to static TiddlyWiki files
+//--
+
+function FileAdaptor()
+{
+}
+
+FileAdaptor.prototype = new AdaptorBase();
+
+FileAdaptor.serverType = 'file';
+FileAdaptor.serverLabel = 'TiddlyWiki';
+
+FileAdaptor.loadTiddlyWikiSuccess = function(context,jqXHR)
+{
+	context.status = true;
+	//# Load the content into a TiddlyWiki() object
+	context.adaptor.store = new TiddlyWiki();
+	if(!context.adaptor.store.importTiddlyWiki(jqXHR.responseText)) {
+		context.statusText = config.messages.invalidFileError.format([context.host]);
+		context.status = false;
+	}
+	context.complete(context,context.userParams);
+};
+
+FileAdaptor.loadTiddlyWikiError = function(context,jqXHR)
+{
+	context.status = false;
+	context.statusText = jqXHR.message;
+	context.complete(context,context.userParams);
+};
+
+// Get the list of workspaces on a given server
+//#   context - passed on as a parameter to the callback function
+//#   userParams - user settable object object that is passed on unchanged to the callback function
+//#   callback - function to be called on completion
+//# Return value is true if the request was successfully issued, false if this connector doesn't support getWorkspaceList(),
+//#   or an error description string if there was a problem
+//# The callback parameters are callback(context,userParams)
+//#   context.status - true if OK, false if error
+//#   context.statusText - error message if there was an error
+//#   context.adaptor - reference to this adaptor object
+//#   userParams - parameters as originally passed into the getWorkspaceList function
+FileAdaptor.prototype.getWorkspaceList = function(context,userParams,callback)
+{
+	context = this.setContext(context,userParams,callback);
+	context.workspaces = [{title:"(default)"}];
+	context.status = true;
+	if(callback)
+		window.setTimeout(function() {callback(context,userParams);},10);
+	return true;
+};
+
+// Gets the list of tiddlers within a given workspace
+//#   context - passed on as a parameter to the callback function
+//#   userParams - user settable object object that is passed on unchanged to the callback function
+//#   callback - function to be called on completion
+//#   filter - filter expression
+//# Return value is true if the request was successfully issued,
+//#   or an error description string if there was a problem
+//# The callback parameters are callback(context,userParams)
+//#   context.status - true if OK, false if error
+//#   context.statusText - error message if there was an error
+//#   context.adaptor - reference to this adaptor object
+//#   context.tiddlers - array of tiddler objects
+//#   userParams - parameters as originally passed into the getTiddlerList function
+FileAdaptor.prototype.getTiddlerList = function(context,userParams,callback,filter)
+{
+	context = this.setContext(context,userParams,callback);
+	if(!context.filter)
+		context.filter = filter;
+	context.complete = FileAdaptor.getTiddlerListComplete;
+	if(this.store) {
+		return context.complete(context,context.userParams);
+	}
+	var options = {
+		type:"GET",
+		url:context.host,
+		processData:false,
+		success:function(data,textStatus,jqXHR) {
+			FileAdaptor.loadTiddlyWikiSuccess(context,jqXHR);
+		},
+		error:function(jqXHR,textStatus,errorThrown) {
+			context.xhr = jqXHR;
+			FileAdaptor.loadTiddlyWikiError(context,jqXHR);
+		}
+	};
+	return ajaxReq(options);
+};
+
+FileAdaptor.getTiddlerListComplete = function(context,userParams)
+{
+	if(context.status) {
+		if(context.filter) {
+			context.tiddlers = context.adaptor.store.filterTiddlers(context.filter);
+		} else {
+			context.tiddlers = [];
+			context.adaptor.store.forEachTiddler(function(title,tiddler) {context.tiddlers.push(tiddler);});
+		}
+		var i;
+		for(i=0; i<context.tiddlers.length; i++) {
+			context.tiddlers[i].fields['server.type'] = FileAdaptor.serverType;
+			context.tiddlers[i].fields['server.host'] = AdaptorBase.minHostName(context.host);
+			context.tiddlers[i].fields['server.page.revision'] = context.tiddlers[i].modified.convertToYYYYMMDDHHMM();
+		}
+		context.status = true;
+	}
+	if(context.callback) {
+		window.setTimeout(function() {context.callback(context,userParams);},10);
+	}
+	return true;
+};
+
+FileAdaptor.prototype.generateTiddlerInfo = function(tiddler)
+{
+	var info = {};
+	info.uri = tiddler.fields['server.host'] + "#" + tiddler.title;
+	return info;
+};
+
+// Retrieve a tiddler from a given workspace on a given server
+//#   title - title of the tiddler to get
+//#   context - passed on as a parameter to the callback function
+//#   userParams - user settable object object that is passed on unchanged to the callback function
+//#   callback - function to be called on completion
+//# Return value is true if the request was successfully issued,
+//#   or an error description string if there was a problem
+//# The callback parameters are callback(context,userParams)
+//#   context.status - true if OK, false if error
+//#   context.statusText - error message if there was an error
+//#   context.adaptor - reference to this adaptor object
+//#   context.tiddler - the retrieved tiddler, or null if it cannot be found
+//#   userParams - parameters as originally passed into the getTiddler function
+FileAdaptor.prototype.getTiddler = function(title,context,userParams,callback)
+{
+	context = this.setContext(context,userParams,callback);
+	context.title = title;
+	context.complete = FileAdaptor.getTiddlerComplete;
+	if(context.adaptor.store) {
+		return context.complete(context,context.userParams);
+	}
+	var options = {
+		type:"GET",
+		url:context.host,
+		processData:false,
+		success:function(data,textStatus,jqXHR) {
+			FileAdaptor.loadTiddlyWikiSuccess(context,jqXHR);
+		},
+		error:function(jqXHR,textStatus,errorThrown) {
+			FileAdaptor.loadTiddlyWikiError(context,jqXHR);
+		}
+	};
+	return ajaxReq(options);
+};
+
+FileAdaptor.getTiddlerComplete = function(context,userParams)
+{
+	var t = context.adaptor.store.fetchTiddler(context.title);
+	if(t) {
+		t.fields['server.type'] = FileAdaptor.serverType;
+		t.fields['server.host'] = AdaptorBase.minHostName(context.host);
+		t.fields['server.page.revision'] = t.modified.convertToYYYYMMDDHHMM();
+		context.tiddler = t;
+		context.status = true;
+	} else { //# tiddler does not exist in document
+		context.status = false;
+	}
+	if(context.allowSynchronous) {
+		context.isSynchronous = true;
+		context.callback(context,userParams);
+	} else {
+		window.setTimeout(function() {context.callback(context,userParams);},10);
+	}
+	return true;
+};
+
+FileAdaptor.prototype.close = function()
+{
+	this.store = null;
+};
+
+config.adaptors[FileAdaptor.serverType] = FileAdaptor;
+
+config.defaultAdaptor = FileAdaptor.serverType;
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/FileSystem.js

@@ -0,0 +1,311 @@
+//--
+//-- Filesystem code
+//--
+//#
+//# This code is designed to be reusable, but please take care,
+//# there are some intricacies that make it tricky to use these
+//# functions with full UTF-8 files. For more details, see:
+//#
+//# http://trac.tiddlywiki.org/ticket/99
+//#
+//#
+//# UTF-8 encoding rules:
+//# 0x0000 - 0x007F:  0xxxxxxx
+//# 0x0080 - 0x07FF:  110xxxxx 10xxxxxx
+//# 0x0800 - 0xFFFF:  1110xxxx 10xxxxxx 10xxxxxx
+
+function convertUTF8ToUnicode(u)
+{
+	return config.browser.isOpera || !window.netscape ? manualConvertUTF8ToUnicode(u) : mozConvertUTF8ToUnicode(u);
+}
+
+function manualConvertUTF8ToUnicode(utf)
+{
+	var uni = utf;
+	var src = 0;
+	var dst = 0;
+	var b1, b2, b3;
+	var c;
+	while(src < utf.length) {
+		b1 = utf.charCodeAt(src++);
+		if(b1 < 0x80) {
+			dst++;
+		} else if(b1 < 0xE0) {
+			b2 = utf.charCodeAt(src++);
+			c = String.fromCharCode(((b1 & 0x1F) << 6) | (b2 & 0x3F));
+			uni = uni.substring(0,dst++).concat(c,utf.substr(src));
+		} else {
+			b2 = utf.charCodeAt(src++);
+			b3 = utf.charCodeAt(src++);
+			c = String.fromCharCode(((b1 & 0xF) << 12) | ((b2 & 0x3F) << 6) | (b3 & 0x3F));
+			uni = uni.substring(0,dst++).concat(c,utf.substr(src));
+		}
+	}
+	return uni;
+}
+
+function mozConvertUTF8ToUnicode(u)
+{
+	try {
+		netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
+		var converter = Components.classes["@mozilla.org/intl/scriptableunicodeconverter"].createInstance(Components.interfaces.nsIScriptableUnicodeConverter);
+		converter.charset = "UTF-8";
+	} catch(ex) {
+		return manualConvertUTF8ToUnicode(u);
+	} // fallback
+	var s = converter.ConvertToUnicode(u);
+	var fin = converter.Finish();
+	return fin.length > 0 ? s+fin : s;
+}
+
+//# convert unicode string to a format suitable for saving to file
+//# this should be UTF8, unless the browser does not support saving non-ASCII characters
+function convertUnicodeToFileFormat(s)
+{
+	return config.browser.isOpera || !window.netscape ? (config.browser.isIE ? convertUnicodeToHtmlEntities(s) : s) : mozConvertUnicodeToUTF8(s);
+}
+
+function convertUnicodeToHtmlEntities(s)
+{
+	var re = /[^\u0000-\u007F]/g;
+	return s.replace(re,function($0) {return "&#" + $0.charCodeAt(0).toString() + ";";});
+}
+
+function convertUnicodeToUTF8(s)
+{
+// return convertUnicodeToFileFormat to allow plugin migration
+	return convertUnicodeToFileFormat(s);
+}
+
+function manualConvertUnicodeToUTF8(s)
+{
+	return unescape(encodeURIComponent(s));
+}
+
+function mozConvertUnicodeToUTF8(s)
+{
+	try {
+		netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
+		var converter = Components.classes["@mozilla.org/intl/scriptableunicodeconverter"].createInstance(Components.interfaces.nsIScriptableUnicodeConverter);
+		converter.charset = "UTF-8";
+	} catch(ex) {
+		return manualConvertUnicodeToUTF8(s);
+	} // fallback
+	var u = converter.ConvertFromUnicode(s);
+	var fin = converter.Finish();
+	return fin.length > 0 ? u + fin : u;
+}
+
+function convertUriToUTF8(uri,charSet)
+{
+	if(window.netscape == undefined || charSet == undefined || charSet == "")
+		return uri;
+	try {
+		netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
+		var converter = Components.classes["@mozilla.org/intl/utf8converterservice;1"].getService(Components.interfaces.nsIUTF8ConverterService);
+	} catch(ex) {
+		return uri;
+	}
+	return converter.convertURISpecToUTF8(uri,charSet);
+}
+
+function copyFile(dest,source)
+{
+	return config.browser.isIE ? ieCopyFile(dest,source) : false;
+}
+
+function saveFile(fileUrl,content)
+{
+	var r = mozillaSaveFile(fileUrl,content);
+	if(!r)
+		r = ieSaveFile(fileUrl,content);
+	if(!r)
+		r = javaSaveFile(fileUrl,content);
+	return r;
+}
+
+function loadFile(fileUrl)
+{
+	var r = mozillaLoadFile(fileUrl);
+	if((r == null) || (r == false))
+		r = ieLoadFile(fileUrl);
+	if((r == null) || (r == false))
+		r = javaLoadFile(fileUrl);
+	return r;
+}
+
+function ieCreatePath(path)
+{
+	try {
+		var fso = new ActiveXObject("Scripting.FileSystemObject");
+	} catch(ex) {
+		return null;
+	}
+
+	//# Remove the filename, if present. Use trailing slash (i.e. "foo\bar\") if no filename.
+	var pos = path.lastIndexOf("\\");
+	if(pos==-1)
+		pos = path.lastIndexOf("/");
+	if(pos!=-1)
+		path = path.substring(0,pos+1);
+
+	//# Walk up the path until we find a folder that exists
+	var scan = [path];
+	var parent = fso.GetParentFolderName(path);
+	while(parent && !fso.FolderExists(parent)) {
+		scan.push(parent);
+		parent = fso.GetParentFolderName(parent);
+	}
+
+	//# Walk back down the path, creating folders
+	for(i=scan.length-1;i>=0;i--) {
+		if(!fso.FolderExists(scan[i])) {
+			fso.CreateFolder(scan[i]);
+		}
+	}
+	return true;
+}
+
+// Returns null if it can't do it, false if there's an error, true if it saved OK
+function ieSaveFile(filePath,content)
+{
+	ieCreatePath(filePath);
+	try {
+		var fso = new ActiveXObject("Scripting.FileSystemObject");
+	} catch(ex) {
+		//# alert("Exception while attempting to save\n\n" + ex.toString());
+		return null;
+	}
+	var file = fso.OpenTextFile(filePath,2,-1,0);
+	file.Write(content);
+	file.Close();
+	return true;
+}
+
+// Returns null if it can't do it, false if there's an error, or a string of the content if successful
+function ieLoadFile(filePath)
+{
+	try {
+		var fso = new ActiveXObject("Scripting.FileSystemObject");
+		var file = fso.OpenTextFile(filePath,1);
+		var content = file.ReadAll();
+		file.Close();
+	} catch(ex) {
+		//# alert("Exception while attempting to load\n\n" + ex.toString());
+		return null;
+	}
+	return content;
+}
+
+function ieCopyFile(dest,source)
+{
+	ieCreatePath(dest);
+	try {
+		var fso = new ActiveXObject("Scripting.FileSystemObject");
+		fso.GetFile(source).Copy(dest);
+	} catch(ex) {
+		return false;
+	}
+	return true;
+}
+
+// Returns null if it can't do it, false if there's an error, true if it saved OK
+function mozillaSaveFile(filePath,content)
+{
+	if(window.Components) {
+		try {
+			netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
+			var file = Components.classes["@mozilla.org/file/local;1"].createInstance(Components.interfaces.nsILocalFile);
+			file.initWithPath(filePath);
+			if(!file.exists())
+				file.create(0,0x01B4);// 0x01B4 = 0664
+			var out = Components.classes["@mozilla.org/network/file-output-stream;1"].createInstance(Components.interfaces.nsIFileOutputStream);
+			out.init(file,0x22,0x04,null);
+			out.write(content,content.length);
+			out.flush();
+			out.close();
+			return true;
+		} catch(ex) {
+			//# alert("Exception while attempting to save\n\n" + ex);
+			return false;
+		}
+	}
+	return null;
+}
+
+// Returns null if it can't do it, false if there's an error, or a string of the content if successful
+function mozillaLoadFile(filePath)
+{
+	if(window.Components) {
+		try {
+			netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
+			var file = Components.classes["@mozilla.org/file/local;1"].createInstance(Components.interfaces.nsILocalFile);
+			file.initWithPath(filePath);
+			if(!file.exists())
+				return null;
+			var inputStream = Components.classes["@mozilla.org/network/file-input-stream;1"].createInstance(Components.interfaces.nsIFileInputStream);
+			inputStream.init(file,0x01,0x04,null);
+			var sInputStream = Components.classes["@mozilla.org/scriptableinputstream;1"].createInstance(Components.interfaces.nsIScriptableInputStream);
+			sInputStream.init(inputStream);
+			var contents = sInputStream.read(sInputStream.available());
+			sInputStream.close();
+			inputStream.close();
+			return contents;
+		} catch(ex) {
+			//# alert("Exception while attempting to load\n\n" + ex);
+			return false;
+		}
+	}
+	return null;
+}
+
+function javaUrlToFilename(url)
+{
+	var f = "//localhost";
+	if(url.indexOf(f) == 0)
+		return url.substring(f.length);
+	var i = url.indexOf(":");
+	return i > 0 ? url.substring(i-1) : url;
+}
+
+function javaSaveFile(filePath,content)
+{
+	try {
+		if(document.applets["TiddlySaver"])
+			return document.applets["TiddlySaver"].saveFile(javaUrlToFilename(filePath),"UTF-8",content);
+	} catch(ex) {
+	}
+	try {
+		var s = new java.io.PrintStream(new java.io.FileOutputStream(javaUrlToFilename(filePath)));
+		s.print(content);
+		s.close();
+	} catch(ex2) {
+		return null;
+	}
+	return true;
+}
+
+function javaLoadFile(filePath)
+{
+	try {
+		if(document.applets["TiddlySaver"]) {
+			var ret = document.applets["TiddlySaver"].loadFile(javaUrlToFilename(filePath),"UTF-8");
+			if(!ret)
+				return null;
+			return String(ret);
+		}
+	} catch(ex) {
+	}
+	var content = [];
+	try {
+		var r = new java.io.BufferedReader(new java.io.FileReader(javaUrlToFilename(filePath)));
+		var line;
+		while((line = r.readLine()) != null)
+			content.push(String(line));
+		r.close();
+	} catch(ex2) {
+		return null;
+	}
+	return content.join("\n");
+}
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Filters.js

@@ -0,0 +1,61 @@
+//--
+//-- Filter a list of tiddlers
+//--
+
+//# Extensible filter functions
+config.filters = {
+	tiddler: function(results,match) {
+		var title = match[1]||match[4];
+		var tiddler = this.fetchTiddler(title);
+		if(tiddler) {
+			results.pushUnique(tiddler);
+		} else if(this.isShadowTiddler(title)) {
+			tiddler = new Tiddler();
+			tiddler.set(title,this.getTiddlerText(title));
+			results.pushUnique(tiddler);
+		} else {
+			results.pushUnique(new Tiddler(title));
+		}
+		return results;
+	},
+	tag: function(results,match) {
+		var m,matched = this.getTaggedTiddlers(match[3]);
+		for(m=0; m<matched.length; m++) {
+			results.pushUnique(matched[m]);
+		}
+		return results;
+	},
+	sort: function(results,match) {
+		return this.sortTiddlers(results,match[3]);
+	},
+	limit: function(results,match) {
+		return results.slice(0,parseInt(match[3],10));
+	},
+	field: function(results,match) {
+		var m,matched = this.getValueTiddlers(match[2],match[3]);
+		for (m = 0; m < matched.length; m++) {
+			results.pushUnique(matched[m]);
+		}
+		return results;
+	}
+};
+
+// Filter a list of tiddlers
+//#   filter - filter expression (eg "tidlertitle [[multi word tiddler title]] [tag[systemConfig]]")
+//# Returns an array of Tiddler() objects that match the filter expression
+TiddlyWiki.prototype.filterTiddlers = function(filter)
+{
+	//# text or [[tiddler title]] or [foo[bar]]
+	var re = /([^\s\[\]]+)|(?:\[([ \w\.\-]+)\[([^\]]+)\]\])|(?:\[\[([^\]]+)\]\])/mg;
+
+	var results = [];
+	if(filter) {
+		var match = re.exec(filter);
+		while(match) {
+			var handler = (match[1]||match[4])?'tiddler':config.filters[match[2]]?match[2]:'field';
+			results = config.filters[handler].call(this,results,match);
+			match = re.exec(filter);
+		}
+	}
+	return results;
+};

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Formatter.js

@@ -0,0 +1,529 @@
+//--
+//-- Standard formatters
+//--
+
+config.formatters = [
+{
+	name: "table",
+	match: "^\\|(?:[^\\n]*)\\|(?:[fhck]?)$",
+	lookaheadRegExp: /^\|([^\n]*)\|([fhck]?)$/mg,
+	rowTermRegExp: /(\|(?:[fhck]?)$\n?)/mg,
+	cellRegExp: /(?:\|([^\n\|]*)\|)|(\|[fhck]?$\n?)/mg,
+	cellTermRegExp: /((?:\x20*)\|)/mg,
+	rowTypes: {"c":"caption", "h":"thead", "":"tbody", "f":"tfoot"},
+	handler: function(w)
+	{
+		var table = createTiddlyElement(w.output,"table",null,"twtable");
+		var prevColumns = [];
+		var currRowType = null;
+		var rowContainer;
+		var rowCount = 0;
+		var onmouseover = function() {jQuery(this).addClass("hoverRow");};
+		var onmouseout = function() {jQuery(this).removeClass("hoverRow");};
+		w.nextMatch = w.matchStart;
+		this.lookaheadRegExp.lastIndex = w.nextMatch;
+		var lookaheadMatch = this.lookaheadRegExp.exec(w.source);
+		while(lookaheadMatch && lookaheadMatch.index == w.nextMatch) {
+			var nextRowType = lookaheadMatch[2];
+			if(nextRowType == "k") {
+				table.className = lookaheadMatch[1];
+				w.nextMatch += lookaheadMatch[0].length+1;
+			} else {
+				if(nextRowType != currRowType) {
+					rowContainer = createTiddlyElement(table,this.rowTypes[nextRowType]);
+					currRowType = nextRowType;
+				}
+				if(currRowType == "c") {
+					// Caption
+					w.nextMatch++;
+					if(rowContainer != table.firstChild)
+						table.insertBefore(rowContainer,table.firstChild);
+					rowContainer.setAttribute("align",rowCount == 0?"top":"bottom");
+					w.subWikifyTerm(rowContainer,this.rowTermRegExp);
+				} else {
+					var theRow = createTiddlyElement(rowContainer,"tr",null,rowCount%2?"oddRow":"evenRow");
+					theRow.onmouseover = onmouseover;
+					theRow.onmouseout = onmouseout;
+					this.rowHandler(w,theRow,prevColumns);
+					rowCount++;
+				}
+			}
+			this.lookaheadRegExp.lastIndex = w.nextMatch;
+			lookaheadMatch = this.lookaheadRegExp.exec(w.source);
+		}
+	},
+	rowHandler: function(w,e,prevColumns)
+	{
+		var col = 0;
+		var colSpanCount = 1;
+		var prevCell = null;
+		this.cellRegExp.lastIndex = w.nextMatch;
+		var cellMatch = this.cellRegExp.exec(w.source);
+		while(cellMatch && cellMatch.index == w.nextMatch) {
+			if(cellMatch[1] == "~") {
+				// Rowspan
+				var last = prevColumns[col];
+				if(last) {
+					last.rowSpanCount++;
+					last.element.setAttribute("rowspan",last.rowSpanCount);
+					last.element.setAttribute("rowSpan",last.rowSpanCount); // Needed for IE
+					last.element.valign = "center";
+					if(colSpanCount > 1) {
+						last.element.setAttribute("colspan",colSpanCount);
+						last.element.setAttribute("colSpan",colSpanCount); // Needed for IE
+						colSpanCount = 1;
+					}
+				}
+				w.nextMatch = this.cellRegExp.lastIndex-1;
+			} else if(cellMatch[1] == ">") {
+				// Colspan
+				colSpanCount++;
+				w.nextMatch = this.cellRegExp.lastIndex-1;
+			} else if(cellMatch[2]) {
+				// End of row
+				if(prevCell && colSpanCount > 1) {
+					prevCell.setAttribute("colspan",colSpanCount);
+					prevCell.setAttribute("colSpan",colSpanCount); // Needed for IE
+				}
+				w.nextMatch = this.cellRegExp.lastIndex;
+				break;
+			} else {
+				// Cell
+				w.nextMatch++;
+				var styles = config.formatterHelpers.inlineCssHelper(w);
+				var spaceLeft = false;
+				var chr = w.source.substr(w.nextMatch,1);
+				while(chr == " ") {
+					spaceLeft = true;
+					w.nextMatch++;
+					chr = w.source.substr(w.nextMatch,1);
+				}
+				var cell;
+				if(chr == "!") {
+					cell = createTiddlyElement(e,"th");
+					w.nextMatch++;
+				} else {
+					cell = createTiddlyElement(e,"td");
+				}
+				prevCell = cell;
+				prevColumns[col] = {rowSpanCount:1,element:cell};
+				if(colSpanCount > 1) {
+					cell.setAttribute("colspan",colSpanCount);
+					cell.setAttribute("colSpan",colSpanCount); // Needed for IE
+					colSpanCount = 1;
+				}
+				config.formatterHelpers.applyCssHelper(cell,styles);
+				w.subWikifyTerm(cell,this.cellTermRegExp);
+				if(w.matchText.substr(w.matchText.length-2,1) == " ") // spaceRight
+					cell.align = spaceLeft ? "center" : "left";
+				else if(spaceLeft)
+					cell.align = "right";
+				w.nextMatch--;
+			}
+			col++;
+			this.cellRegExp.lastIndex = w.nextMatch;
+			cellMatch = this.cellRegExp.exec(w.source);
+		}
+	}
+},
+
+{
+	name: "heading",
+	match: "^!{1,6}",
+	termRegExp: /(\n)/mg,
+	handler: function(w)
+	{
+		w.subWikifyTerm(createTiddlyElement(w.output,"h" + w.matchLength),this.termRegExp);
+	}
+},
+
+{
+	name: "list",
+	match: "^(?:[\\*#;:]+)",
+	lookaheadRegExp: /^(?:(?:(\*)|(#)|(;)|(:))+)/mg,
+	termRegExp: /(\n)/mg,
+	handler: function(w)
+	{
+		var stack = [w.output];
+		var currLevel = 0, currType = null;
+		var listLevel, listType, itemType, baseType;
+		w.nextMatch = w.matchStart;
+		this.lookaheadRegExp.lastIndex = w.nextMatch;
+		var lookaheadMatch = this.lookaheadRegExp.exec(w.source);
+		while(lookaheadMatch && lookaheadMatch.index == w.nextMatch) {
+			if(lookaheadMatch[1]) {
+				listType = "ul";
+				itemType = "li";
+			} else if(lookaheadMatch[2]) {
+				listType = "ol";
+				itemType = "li";
+			} else if(lookaheadMatch[3]) {
+				listType = "dl";
+				itemType = "dt";
+			} else if(lookaheadMatch[4]) {
+				listType = "dl";
+				itemType = "dd";
+			}
+			if(!baseType)
+				baseType = listType;
+			listLevel = lookaheadMatch[0].length;
+			w.nextMatch += lookaheadMatch[0].length;
+			var t;
+			if(listLevel > currLevel) {
+				for(t=currLevel; t<listLevel; t++) {
+					var target = (currLevel == 0) ? stack[stack.length-1] : stack[stack.length-1].lastChild;
+					stack.push(createTiddlyElement(target,listType));
+				}
+			} else if(listType!=baseType && listLevel==1) {
+				w.nextMatch -= lookaheadMatch[0].length;
+				return;
+			} else if(listLevel < currLevel) {
+				for(t=currLevel; t>listLevel; t--)
+					stack.pop();
+			} else if(listLevel == currLevel && listType != currType) {
+				stack.pop();
+				stack.push(createTiddlyElement(stack[stack.length-1].lastChild,listType));
+			}
+			currLevel = listLevel;
+			currType = listType;
+			var e = createTiddlyElement(stack[stack.length-1],itemType);
+			w.subWikifyTerm(e,this.termRegExp);
+			this.lookaheadRegExp.lastIndex = w.nextMatch;
+			lookaheadMatch = this.lookaheadRegExp.exec(w.source);
+		}
+	}
+},
+
+{
+	name: "quoteByBlock",
+	match: "^<<<\\n",
+	termRegExp: /(^<<<(\n|$))/mg,
+	element: "blockquote",
+	handler: config.formatterHelpers.createElementAndWikify
+},
+
+{
+	name: "quoteByLine",
+	match: "^>+",
+	lookaheadRegExp: /^>+/mg,
+	termRegExp: /(\n)/mg,
+	element: "blockquote",
+	handler: function(w)
+	{
+		var stack = [w.output];
+		var currLevel = 0;
+		var newLevel = w.matchLength;
+		var t,matched;
+		do {
+			if(newLevel > currLevel) {
+				for(t=currLevel; t<newLevel; t++)
+					stack.push(createTiddlyElement(stack[stack.length-1],this.element));
+			} else if(newLevel < currLevel) {
+				for(t=currLevel; t>newLevel; t--)
+					stack.pop();
+			}
+			currLevel = newLevel;
+			w.subWikifyTerm(stack[stack.length-1],this.termRegExp);
+			createTiddlyElement(stack[stack.length-1],"br");
+			this.lookaheadRegExp.lastIndex = w.nextMatch;
+			var lookaheadMatch = this.lookaheadRegExp.exec(w.source);
+			matched = lookaheadMatch && lookaheadMatch.index == w.nextMatch;
+			if(matched) {
+				newLevel = lookaheadMatch[0].length;
+				w.nextMatch += lookaheadMatch[0].length;
+			}
+		} while(matched);
+	}
+},
+
+{
+	name: "rule",
+	match: "^----+$\\n?|<hr ?/?>\\n?",
+	handler: function(w)
+	{
+		createTiddlyElement(w.output,"hr");
+	}
+},
+
+{
+	name: "monospacedByLine",
+	match: "^(?:/\\*\\{\\{\\{\\*/|\\{\\{\\{|//\\{\\{\\{|<!--\\{\\{\\{-->)\\n",
+	element: "pre",
+	handler: function(w)
+	{
+		switch(w.matchText) {
+		case "/*{{{*/\n": // CSS
+			this.lookaheadRegExp = /\/\*\{\{\{\*\/\n*((?:^[^\n]*\n)+?)(\n*^\f*\/\*\}\}\}\*\/$\n?)/mg;
+			break;
+		case "{{{\n": // monospaced block
+			this.lookaheadRegExp = /^\{\{\{\n((?:^[^\n]*\n)+?)(^\f*\}\}\}$\n?)/mg;
+			break;
+		case "//{{{\n": // plugin
+			this.lookaheadRegExp = /^\/\/\{\{\{\n\n*((?:^[^\n]*\n)+?)(\n*^\f*\/\/\}\}\}$\n?)/mg;
+			break;
+		case "<!--{{{-->\n": //template
+			this.lookaheadRegExp = /<!--\{\{\{-->\n*((?:^[^\n]*\n)+?)(\n*^\f*<!--\}\}\}-->$\n?)/mg;
+			break;
+		default:
+			break;
+		}
+		config.formatterHelpers.enclosedTextHelper.call(this,w);
+	}
+},
+
+{
+	name: "wikifyComment",
+	match: "^(?:/\\*\\*\\*|<!---)\\n",
+	handler: function(w)
+	{
+		var termRegExp = (w.matchText == "/***\n") ? (/(^\*\*\*\/\n)/mg) : (/(^--->\n)/mg);
+		w.subWikifyTerm(w.output,termRegExp);
+	}
+},
+
+{
+	name: "macro",
+	match: "<<",
+	lookaheadRegExp: /<<([^>\s]+)(?:\s*)((?:[^>]|(?:>(?!>)))*)>>/mg,
+	handler: function(w)
+	{
+		this.lookaheadRegExp.lastIndex = w.matchStart;
+		var lookaheadMatch = this.lookaheadRegExp.exec(w.source);
+		if(lookaheadMatch && lookaheadMatch.index == w.matchStart && lookaheadMatch[1]) {
+			w.nextMatch = this.lookaheadRegExp.lastIndex;
+			invokeMacro(w.output,lookaheadMatch[1],lookaheadMatch[2],w,w.tiddler);
+		}
+	}
+},
+
+{
+	name: "prettyLink",
+	match: "\\[\\[",
+	lookaheadRegExp: /\[\[(.*?)(?:\|(~)?(.*?))?\]\]/mg,
+	handler: function(w)
+	{
+		this.lookaheadRegExp.lastIndex = w.matchStart;
+		var lookaheadMatch = this.lookaheadRegExp.exec(w.source);
+		if(lookaheadMatch && lookaheadMatch.index == w.matchStart) {
+			var e;
+			var text = lookaheadMatch[1];
+			if(lookaheadMatch[3]) {
+				// Pretty bracketted link
+				var link = lookaheadMatch[3];
+				e = (!lookaheadMatch[2] && config.formatterHelpers.isExternalLink(link)) ?
+						createExternalLink(w.output,link) : createTiddlyLink(w.output,link,false,null,w.isStatic,w.tiddler);
+			} else {
+				// Simple bracketted link
+				e = createTiddlyLink(w.output,text,false,null,w.isStatic,w.tiddler);
+			}
+			createTiddlyText(e,text);
+			w.nextMatch = this.lookaheadRegExp.lastIndex;
+		}
+	}
+},
+
+{
+	name: "wikiLink",
+	match: config.textPrimitives.unWikiLink+"?"+config.textPrimitives.wikiLink,
+	handler: function(w)
+	{
+		if(w.matchText.substr(0,1) == config.textPrimitives.unWikiLink) {
+			w.outputText(w.output,w.matchStart+1,w.nextMatch);
+			return;
+		}
+		if(w.matchStart > 0) {
+			var preRegExp = new RegExp(config.textPrimitives.anyLetterStrict,"mg");
+			preRegExp.lastIndex = w.matchStart-1;
+			var preMatch = preRegExp.exec(w.source);
+			if(preMatch.index == w.matchStart-1) {
+				w.outputText(w.output,w.matchStart,w.nextMatch);
+				return;
+			}
+		}
+		if(w.autoLinkWikiWords || store.isShadowTiddler(w.matchText)) {
+			var link = createTiddlyLink(w.output,w.matchText,false,null,w.isStatic,w.tiddler);
+			w.outputText(link,w.matchStart,w.nextMatch);
+		} else {
+			w.outputText(w.output,w.matchStart,w.nextMatch);
+		}
+	}
+},
+
+{
+	name: "urlLink",
+	match: config.textPrimitives.urlPattern,
+	handler: function(w)
+	{
+		w.outputText(createExternalLink(w.output,w.matchText),w.matchStart,w.nextMatch);
+	}
+},
+
+{
+	name: "image",
+	match: "\\[[<>]?[Ii][Mm][Gg]\\[",
+	//# [<] sequence below is to avoid lessThan-questionMark sequence so TiddlyWikis can be included in PHP files
+	lookaheadRegExp: /\[([<]?)(>?)[Ii][Mm][Gg]\[(?:([^\|\]]+)\|)?([^\[\]\|]+)\](?:\[([^\]]*)\])?\]/mg,
+	handler: function(w)
+	{
+		this.lookaheadRegExp.lastIndex = w.matchStart;
+		var lookaheadMatch = this.lookaheadRegExp.exec(w.source);
+		if(lookaheadMatch && lookaheadMatch.index == w.matchStart) {
+			var e = w.output;
+			if(lookaheadMatch[5]) {
+				var link = lookaheadMatch[5];
+				e = config.formatterHelpers.isExternalLink(link) ? createExternalLink(w.output,link) : createTiddlyLink(w.output,link,false,null,w.isStatic,w.tiddler);
+				jQuery(e).addClass("imageLink");
+			}
+			var img = createTiddlyElement(e,"img");
+			if(lookaheadMatch[1])
+				img.align = "left";
+			else if(lookaheadMatch[2])
+				img.align = "right";
+			if(lookaheadMatch[3]) {
+				img.title = lookaheadMatch[3];
+				img.setAttribute("alt",lookaheadMatch[3]);
+			}
+			img.src = lookaheadMatch[4];
+			w.nextMatch = this.lookaheadRegExp.lastIndex;
+		}
+	}
+},
+
+{
+	name: "html",
+	match: "<[Hh][Tt][Mm][Ll]>",
+	lookaheadRegExp: /<[Hh][Tt][Mm][Ll]>((?:.|\n)*?)<\/[Hh][Tt][Mm][Ll]>/mg,
+	handler: function(w)
+	{
+		this.lookaheadRegExp.lastIndex = w.matchStart;
+		var lookaheadMatch = this.lookaheadRegExp.exec(w.source);
+		if(lookaheadMatch && lookaheadMatch.index == w.matchStart) {
+			createTiddlyElement(w.output,"span").innerHTML = lookaheadMatch[1];
+			w.nextMatch = this.lookaheadRegExp.lastIndex;
+		}
+	}
+},
+
+{
+	name: "commentByBlock",
+	match: "/%",
+	lookaheadRegExp: /\/%((?:.|\n)*?)%\//mg,
+	handler: function(w)
+	{
+		this.lookaheadRegExp.lastIndex = w.matchStart;
+		var lookaheadMatch = this.lookaheadRegExp.exec(w.source);
+		if(lookaheadMatch && lookaheadMatch.index == w.matchStart)
+			w.nextMatch = this.lookaheadRegExp.lastIndex;
+	}
+},
+
+{
+	name: "characterFormat",
+	match: "''|//|__|\\^\\^|~~|--(?!\\s|$)|\\{\\{\\{",
+	handler: function(w)
+	{
+		switch(w.matchText) {
+		case "''":
+			w.subWikifyTerm(w.output.appendChild(document.createElement("strong")),/('')/mg);
+			break;
+		case "//":
+			w.subWikifyTerm(createTiddlyElement(w.output,"em"),/(\/\/)/mg);
+			break;
+		case "__":
+			w.subWikifyTerm(createTiddlyElement(w.output,"u"),/(__)/mg);
+			break;
+		case "^^":
+			w.subWikifyTerm(createTiddlyElement(w.output,"sup"),/(\^\^)/mg);
+			break;
+		case "~~":
+			w.subWikifyTerm(createTiddlyElement(w.output,"sub"),/(~~)/mg);
+			break;
+		case "--":
+			w.subWikifyTerm(createTiddlyElement(w.output,"strike"),/(--)/mg);
+			break;
+		case "{{{":
+			var lookaheadRegExp = /\{\{\{((?:.|\n)*?)\}\}\}/mg;
+			lookaheadRegExp.lastIndex = w.matchStart;
+			var lookaheadMatch = lookaheadRegExp.exec(w.source);
+			if(lookaheadMatch && lookaheadMatch.index == w.matchStart) {
+				createTiddlyElement(w.output,"code",null,null,lookaheadMatch[1]);
+				w.nextMatch = lookaheadRegExp.lastIndex;
+			}
+			break;
+		}
+	}
+},
+
+{
+	name: "customFormat",
+	match: "@@|\\{\\{",
+	handler: function(w)
+	{
+		switch(w.matchText) {
+		case "@@":
+			var e = createTiddlyElement(w.output,"span");
+			var styles = config.formatterHelpers.inlineCssHelper(w);
+			if(styles.length == 0)
+				e.className = "marked";
+			else
+				config.formatterHelpers.applyCssHelper(e,styles);
+			w.subWikifyTerm(e,/(@@)/mg);
+			break;
+		case "{{":
+			var lookaheadRegExp = /\{\{[\s]*([\w]+[\s\w]*)[\s]*\{(\n?)/mg;
+			lookaheadRegExp.lastIndex = w.matchStart;
+			var lookaheadMatch = lookaheadRegExp.exec(w.source);
+			if(lookaheadMatch) {
+				w.nextMatch = lookaheadRegExp.lastIndex;
+				e = createTiddlyElement(w.output,lookaheadMatch[2] == "\n" ? "div" : "span",null,lookaheadMatch[1]);
+				w.subWikifyTerm(e,/(\}\}\})/mg);
+			}
+			break;
+		}
+	}
+},
+
+{
+	name: "mdash",
+	match: "--",
+	handler: function(w)
+	{
+		createTiddlyElement(w.output,"span").innerHTML = "&mdash;";
+	}
+},
+
+{
+	name: "lineBreak",
+	match: "\\n|<br ?/?>",
+	handler: function(w)
+	{
+		createTiddlyElement(w.output,"br");
+	}
+},
+
+{
+	name: "rawText",
+	match: "\"{3}|<nowiki>",
+	lookaheadRegExp: /(?:\"{3}|<nowiki>)((?:.|\n)*?)(?:\"{3}|<\/nowiki>)/mg,
+	handler: function(w)
+	{
+		this.lookaheadRegExp.lastIndex = w.matchStart;
+		var lookaheadMatch = this.lookaheadRegExp.exec(w.source);
+		if(lookaheadMatch && lookaheadMatch.index == w.matchStart) {
+			createTiddlyElement(w.output,"span",null,null,lookaheadMatch[1]);
+			w.nextMatch = this.lookaheadRegExp.lastIndex;
+		}
+	}
+},
+
+{
+	name: "htmlEntitiesEncoding",
+	match: "(?:(?:&#?[a-zA-Z0-9]{2,8};|.)(?:&#?(?:x0*(?:3[0-6][0-9a-fA-F]|1D[c-fC-F][0-9a-fA-F]|20[d-fD-F][0-9a-fA-F]|FE2[0-9a-fA-F])|0*(?:76[89]|7[7-9][0-9]|8[0-7][0-9]|761[6-9]|76[2-7][0-9]|84[0-3][0-9]|844[0-7]|6505[6-9]|6506[0-9]|6507[0-1]));)+|&#?[a-zA-Z0-9]{2,8};)",
+	handler: function(w)
+	{
+		createTiddlyElement(w.output,"span").innerHTML = w.matchText;
+	}
+}
+
+];
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/FormatterHelpers.js

@@ -0,0 +1,94 @@
+//--
+//-- Formatter helpers
+//--
+
+function Formatter(formatters)
+{
+	var n;
+	this.formatters = [];
+	var pattern = [];
+	for(n=0; n<formatters.length; n++) {
+		pattern.push("(" + formatters[n].match + ")");
+		this.formatters.push(formatters[n]);
+	}
+	this.formatterRegExp = new RegExp(pattern.join("|"),"mg");
+}
+
+config.formatterHelpers = {
+
+	createElementAndWikify: function(w)
+	{
+		w.subWikifyTerm(createTiddlyElement(w.output,this.element),this.termRegExp);
+	},
+
+	inlineCssHelper: function(w)
+	{
+		var styles = [];
+		config.textPrimitives.cssLookaheadRegExp.lastIndex = w.nextMatch;
+		var lookaheadMatch = config.textPrimitives.cssLookaheadRegExp.exec(w.source);
+		while(lookaheadMatch && lookaheadMatch.index == w.nextMatch) {
+			var s,v;
+			if(lookaheadMatch[1]) {
+				s = lookaheadMatch[1].unDash();
+				v = lookaheadMatch[2];
+			} else {
+				s = lookaheadMatch[3].unDash();
+				v = lookaheadMatch[4];
+			}
+			if(s=="bgcolor")
+				s = "backgroundColor";
+			if(s=="float")
+				s = "cssFloat";
+			styles.push({style: s, value: v});
+			w.nextMatch = lookaheadMatch.index + lookaheadMatch[0].length;
+			config.textPrimitives.cssLookaheadRegExp.lastIndex = w.nextMatch;
+			lookaheadMatch = config.textPrimitives.cssLookaheadRegExp.exec(w.source);
+		}
+		return styles;
+	},
+
+	applyCssHelper: function(e,styles)
+	{
+		var t;
+		for(t=0; t< styles.length; t++) {
+			try {
+				e.style[styles[t].style] = styles[t].value;
+			} catch (ex) {
+			}
+		}
+	},
+
+	enclosedTextHelper: function(w)
+	{
+		this.lookaheadRegExp.lastIndex = w.matchStart;
+		var lookaheadMatch = this.lookaheadRegExp.exec(w.source);
+		if(lookaheadMatch && lookaheadMatch.index == w.matchStart) {
+			var text = lookaheadMatch[1];
+			if(config.browser.isIE)
+				text = text.replace(/\n/g,"\r");
+			createTiddlyElement(w.output,this.element,null,null,text);
+			w.nextMatch = lookaheadMatch.index + lookaheadMatch[0].length;
+		}
+	},
+
+	isExternalLink: function(link)
+	{
+		if(store.tiddlerExists(link) || store.isShadowTiddler(link)) {
+			//# Definitely not an external link
+			return false;
+		}
+		var urlRegExp = new RegExp(config.textPrimitives.urlPattern,"mg");
+		if(urlRegExp.exec(link)) {
+			//# Definitely an external link
+			return true;
+		}
+		if(link.indexOf(".")!=-1 || link.indexOf("\\")!=-1 || link.indexOf("/")!=-1 || link.indexOf("#")!=-1) {
+			//# Link contains . / \ or # so is probably an external link
+			return true;
+		}
+		//# Otherwise assume it is not an external link
+		return false;
+	}
+
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Guide.js

@@ -0,0 +1,12 @@
+//
+// Please note:
+//
+// * This code is designed to be readable but for compactness it only includes brief comments. You can see fuller comments
+//   in the project repository at https://github.com/TiddlyWiki/tiddlywiki
+//
+// * You should never need to modify this source code directly. TiddlyWiki is carefully designed to allow deep customisation
+//   without changing the core code. Please consult the development group at http://groups.google.com/group/TiddlyWikiDev
+//
+// JSLint directives
+/*global jQuery:false, version:false */
+/*jslint bitwise:true, browser:true, confusion:true, eqeq:true, evil:true, forin:true, maxerr:100, plusplus:true, regexp:true, sloppy:true, sub:true, undef:true, unparam:true, vars:true, white:true */

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Http.js

@@ -0,0 +1,75 @@
+//--
+//-- HTTP request code
+//--
+
+//# Perform an http request using the jQuery ajax function
+function ajaxReq(args)
+{
+	if(window.Components && window.netscape && window.netscape.security && document.location.protocol.indexOf("http") == -1)
+		window.netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead");
+	return jQuery.ajax(args);
+}
+
+//# Perform an http request
+//#   type - GET/POST/PUT/DELETE
+//#   url - the source url
+//#   data - optional data for POST and PUT
+//#   contentType - optionalContent type for the data (defaults to application/x-www-form-urlencoded)
+//#   username - optional username for basic authentication
+//#   password - optional password for basic authentication
+//#   callback - function to call when there is a response
+//#   params - parameter object that gets passed to the callback for storing it's state
+//#   headers - optional hashmap of additional headers
+//#   allowCache - unless true, adds a "nocache=" parameter to the URL
+//# Return value is the underlying XMLHttpRequest object, or a string if there was an error
+//# Callback function is called like this:
+//#   callback(status,params,responseText,url,xhr)
+//#     status - true if OK, false if error
+//#     params - the parameter object provided to loadRemoteFile()
+//#     responseText - the text of the file
+//#     url - requested URL
+//#     xhr - the underlying XMLHttpRequest object
+function httpReq(type,url,callback,params,headers,data,contentType,username,password,allowCache)
+{
+	var httpSuccess = function(xhr) {
+		try {
+			// IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450
+			return (!xhr.status && location.protocol === "file:") ||
+				(xhr.status >= 200 && xhr.status < 300) ||
+				xhr.status === 304 || xhr.status === 1223;
+		} catch(e) {}
+		return false;
+	};
+
+	var options = {
+		type:type,
+		url:url,
+		processData:false,
+		data:data,
+		cache:!!allowCache,
+		beforeSend: function(xhr) {
+			var i;
+			for(i in headers)
+				xhr.setRequestHeader(i,headers[i]);
+			xhr.setRequestHeader("X-Requested-With", "TiddlyWiki " + formatVersion());
+		}
+	};
+
+	if(callback) {
+		options.complete = function(xhr,textStatus) {
+			if(httpSuccess(xhr))
+				callback(true,params,xhr.responseText,url,xhr);
+			else
+				callback(false,params,null,url,xhr);
+		};
+	}
+	if(contentType)
+		options.contentType = contentType;
+	if(username)
+		options.username = username;
+	if(password)
+		options.password = password;
+	if(window.Components && window.netscape && window.netscape.security && document.location.protocol.indexOf("http") == -1)
+		window.netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead");
+	return jQuery.ajax(options);
+}

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Import.js

@@ -0,0 +1,390 @@
+//--
+//-- ImportTiddlers macro
+//--
+
+config.macros.importTiddlers.handler = function(place,macroName,params,wikifier,paramString,tiddler)
+{
+	if(readOnly) {
+		createTiddlyElement(place,"div",null,"marked",this.readOnlyWarning);
+		return;
+	}
+	var w = new Wizard();
+	w.createWizard(place,this.wizardTitle);
+	this.restart(w);
+};
+
+config.macros.importTiddlers.onCancel = function(e)
+{
+	var wizard = new Wizard(this);
+	wizard.clear();
+	config.macros.importTiddlers.restart(wizard);
+	return false;
+};
+
+config.macros.importTiddlers.onClose = function(e)
+{
+	backstage.hidePanel();
+	return false;
+};
+
+config.macros.importTiddlers.restart = function(wizard)
+{
+	var me = config.macros.importTiddlers;
+	wizard.addStep(this.step1Title,this.step1Html);
+	var t,s = wizard.getElement("selTypes");
+	for(t in config.adaptors) {
+		var e = createTiddlyElement(s,"option",null,null,config.adaptors[t].serverLabel || t);
+		e.value = t;
+	}
+	if(config.defaultAdaptor)
+		s.value = config.defaultAdaptor;
+	s = wizard.getElement("selFeeds");
+	var feeds = this.getFeeds();
+	for(t in feeds) {
+		e = createTiddlyElement(s,"option",null,null,t);
+		e.value = t;
+	}
+	wizard.setValue("feeds",feeds);
+	s.onchange = me.onFeedChange;
+	var fileInput = wizard.getElement("txtBrowse");
+	fileInput.onchange = me.onBrowseChange;
+	fileInput.onkeyup = me.onBrowseChange;
+	wizard.setButtons([{caption: this.openLabel, tooltip: this.openPrompt, onClick: me.onOpen}]);
+	wizard.formElem.action = "javascript:;";
+	wizard.formElem.onsubmit = function() {
+		if(!this.txtPath || this.txtPath.value.length) //# check for manually entered path in first step
+			this.lastChild.firstChild.onclick();
+	};
+};
+
+config.macros.importTiddlers.getFeeds = function()
+{
+	var feeds = {};
+	var t,tagged = store.getTaggedTiddlers("systemServer","title");
+	for(t=0; t<tagged.length; t++) {
+		var title = tagged[t].title;
+		var serverType = store.getTiddlerSlice(title,"Type");
+		if(!serverType)
+			serverType = "file";
+		feeds[title] = {title: title,
+						url: store.getTiddlerSlice(title,"URL"),
+						workspace: store.getTiddlerSlice(title,"Workspace"),
+						workspaceList: store.getTiddlerSlice(title,"WorkspaceList"),
+						tiddlerFilter: store.getTiddlerSlice(title,"TiddlerFilter"),
+						serverType: serverType,
+						description: store.getTiddlerSlice(title,"Description")};
+	}
+	return feeds;
+};
+
+config.macros.importTiddlers.onFeedChange = function(e)
+{
+	var wizard = new Wizard(this);
+	var selTypes = wizard.getElement("selTypes");
+	var fileInput = wizard.getElement("txtPath");
+	var feeds = wizard.getValue("feeds");
+	var f = feeds[this.value];
+	if(f) {
+		selTypes.value = f.serverType;
+		fileInput.value = f.url;
+		wizard.setValue("feedName",f.serverType);
+		wizard.setValue("feedHost",f.url);
+		wizard.setValue("feedWorkspace",f.workspace);
+		wizard.setValue("feedWorkspaceList",f.workspaceList);
+		wizard.setValue("feedTiddlerFilter",f.tiddlerFilter);
+	}
+	return false;
+};
+
+config.macros.importTiddlers.onBrowseChange = function(e)
+{
+	var wizard = new Wizard(this);
+	var file = this.value;
+	if(this.files && this.files[0]) {
+		file = this.files[0].fileName;
+		try {
+			if(typeof(netscape) !== "undefined") {
+				netscape.security.PrivilegeManager.enablePrivilege("UniversalFileRead");
+			}
+		} catch (ex) {
+			showException(ex);
+		}
+	}
+	var fileInput = wizard.getElement("txtPath");
+	fileInput.value = config.macros.importTiddlers.getURLFromLocalPath(file);
+	var serverType = wizard.getElement("selTypes");
+	serverType.value = "file";
+	return true;
+};
+
+config.macros.importTiddlers.getURLFromLocalPath = function(v)
+{
+	if(!v || !v.length)
+		return v;
+	v = v.replace(/\\/g,"/"); // use "/" for cross-platform consistency
+	var u;
+	var t = v.split(":");
+	var p = t[1] || t[0]; // remove drive letter (if any)
+	if(t[1] && (t[0] == "http" || t[0] == "https" || t[0] == "file")) {
+		//# input is already a URL
+		u = v;
+	} else if(p.substr(0,1)=="/") {
+		//# path is absolute, add protocol+domain+extra slash (if drive letter)
+		u = document.location.protocol + "//" + document.location.hostname + (t[1] ? "/" : "") + v;
+	} else {
+		//# path is relative, add current document protocol+domain+path
+		var c = document.location.href.replace(/\\/g,"/");
+		var pos = c.lastIndexOf("/");
+		if(pos!=-1)
+			c = c.substr(0,pos); // remove filename
+		u = c + "/" + p;
+	}
+	return u;
+};
+
+config.macros.importTiddlers.onOpen = function(e)
+{
+	var me = config.macros.importTiddlers;
+	var wizard = new Wizard(this);
+	var fileInput = wizard.getElement("txtPath");
+	var url = fileInput.value;
+	var serverType = wizard.getElement("selTypes").value || config.defaultAdaptor;
+	var adaptor = new config.adaptors[serverType]();
+	wizard.setValue("adaptor",adaptor);
+	wizard.setValue("serverType",serverType);
+	wizard.setValue("host",url);
+	adaptor.openHost(url,null,wizard,me.onOpenHost);
+	wizard.setButtons([{caption: me.cancelLabel, tooltip: me.cancelPrompt, onClick: me.onCancel}],me.statusOpenHost);
+	return false;
+};
+
+config.macros.importTiddlers.onOpenHost = function(context,wizard)
+{
+	var me = config.macros.importTiddlers;
+	var adaptor = wizard.getValue("adaptor");
+	if(context.status !== true)
+		displayMessage("Error in importTiddlers.onOpenHost: " + context.statusText);
+	adaptor.getWorkspaceList(context,wizard,me.onGetWorkspaceList);
+	wizard.setButtons([{caption: me.cancelLabel, tooltip: me.cancelPrompt, onClick: me.onCancel}],me.statusGetWorkspaceList);
+};
+
+config.macros.importTiddlers.onGetWorkspaceList = function(context,wizard)
+{
+	var me = config.macros.importTiddlers;
+	if(context.status !== true)
+		displayMessage("Error in importTiddlers.onGetWorkspaceList: " + context.statusText);
+	wizard.setValue("context",context);
+	var workspace = wizard.getValue("feedWorkspace");
+	if(!workspace && context.workspaces.length==1)
+		workspace = context.workspaces[0].title;
+	if(workspace) {
+		//# if there is only one workspace, then open it directly
+		context.adaptor.openWorkspace(workspace,context,wizard,me.onOpenWorkspace);
+		wizard.setValue("workspace",workspace);
+		wizard.setButtons([{caption: me.cancelLabel, tooltip: me.cancelPrompt, onClick: me.onCancel}],me.statusOpenWorkspace);
+		return;
+	}
+	wizard.addStep(me.step2Title,me.step2Html);
+	var t,s = wizard.getElement("selWorkspace");
+	s.onchange = me.onWorkspaceChange;
+	for(t=0; t<context.workspaces.length; t++) {
+		var e = createTiddlyElement(s,"option",null,null,context.workspaces[t].title);
+		e.value = context.workspaces[t].title;
+	}
+	var workspaceList = wizard.getValue("feedWorkspaceList");
+	if(workspaceList) {
+		var n,list = workspaceList.parseParams("workspace",null,false,true);
+		for(n=1; n<list.length; n++) {
+			if(context.workspaces.findByField("title",list[n].value) == null) {
+				e = createTiddlyElement(s,"option",null,null,list[n].value);
+				e.value = list[n].value;
+			}
+		}
+	}
+	if(workspace) {
+		t = wizard.getElement("txtWorkspace");
+		t.value = workspace;
+	}
+	wizard.setButtons([{caption: me.openLabel, tooltip: me.openPrompt, onClick: me.onChooseWorkspace}]);
+};
+
+config.macros.importTiddlers.onWorkspaceChange = function(e)
+{
+	var wizard = new Wizard(this);
+	var t = wizard.getElement("txtWorkspace");
+	t.value = this.value;
+	this.selectedIndex = 0;
+	return false;
+};
+
+config.macros.importTiddlers.onChooseWorkspace = function(e)
+{
+	var me = config.macros.importTiddlers;
+	var wizard = new Wizard(this);
+	var adaptor = wizard.getValue("adaptor");
+	var workspace = wizard.getElement("txtWorkspace").value;
+	wizard.setValue("workspace",workspace);
+	var context = wizard.getValue("context");
+	adaptor.openWorkspace(workspace,context,wizard,me.onOpenWorkspace);
+	wizard.setButtons([{caption: me.cancelLabel, tooltip: me.cancelPrompt, onClick: me.onCancel}],me.statusOpenWorkspace);
+	return false;
+};
+
+config.macros.importTiddlers.onOpenWorkspace = function(context,wizard)
+{
+	var me = config.macros.importTiddlers;
+	if(context.status !== true)
+		displayMessage("Error in importTiddlers.onOpenWorkspace: " + context.statusText);
+	var adaptor = wizard.getValue("adaptor");
+	adaptor.getTiddlerList(context,wizard,me.onGetTiddlerList,wizard.getValue("feedTiddlerFilter"));
+	wizard.setButtons([{caption: me.cancelLabel, tooltip: me.cancelPrompt, onClick: me.onCancel}],me.statusGetTiddlerList);
+};
+
+config.macros.importTiddlers.onGetTiddlerList = function(context,wizard)
+{
+	var me = config.macros.importTiddlers;
+	if(context.status !== true) {
+		var error = context.statusText||me.errorGettingTiddlerList;
+		if(context.host.indexOf("file://") === 0) {
+			error = me.errorGettingTiddlerListFile;
+		} else {
+			error = context.xhr && context.xhr.status == 404 ? me.errorGettingTiddlerListHttp404 :
+				me.errorGettingTiddlerListHttp;
+		}
+		wizard.setButtons([{caption: me.cancelLabel, tooltip: me.cancelPrompt, onClick: me.onCancel}],"");
+		jQuery("span.status", wizard.footerEl).html(error); // so error message can be html
+		return;
+	}
+	// Extract data for the listview
+	var listedTiddlers = [];
+	if(context.tiddlers) {
+		var n;
+		for(n=0; n<context.tiddlers.length; n++) {
+			var tiddler = context.tiddlers[n];
+			listedTiddlers.push({
+				title: tiddler.title,
+				modified: tiddler.modified,
+				modifier: tiddler.modifier,
+				text: tiddler.text ? wikifyPlainText(tiddler.text,100) : "",
+				tags: tiddler.tags,
+				size: tiddler.text ? tiddler.text.length : 0,
+				tiddler: tiddler
+			});
+		}
+	}
+	listedTiddlers.sort(function(a,b) {return a.title < b.title ? -1 : (a.title == b.title ? 0 : +1);});
+	// Display the listview
+	wizard.addStep(me.step3Title,me.step3Html);
+	var markList = wizard.getElement("markList");
+	var listWrapper = document.createElement("div");
+	markList.parentNode.insertBefore(listWrapper,markList);
+	var listView = ListView.create(listWrapper,listedTiddlers,me.listViewTemplate);
+	wizard.setValue("listView",listView);
+	wizard.setValue("context",context);
+	var txtSaveTiddler = wizard.getElement("txtSaveTiddler");
+	txtSaveTiddler.value = me.generateSystemServerName(wizard);
+	wizard.setButtons([
+			{caption: me.cancelLabel, tooltip: me.cancelPrompt, onClick: me.onCancel},
+			{caption: me.importLabel, tooltip: me.importPrompt, onClick: me.doImport}
+		]);
+};
+
+config.macros.importTiddlers.generateSystemServerName = function(wizard)
+{
+	var serverType = wizard.getValue("serverType");
+	var host = wizard.getValue("host");
+	var workspace = wizard.getValue("workspace");
+	var pattern = config.macros.importTiddlers[workspace ? "systemServerNamePattern" : "systemServerNamePatternNoWorkspace"];
+	return pattern.format([serverType,host,workspace]);
+};
+
+config.macros.importTiddlers.saveServerTiddler = function(wizard)
+{
+	var me = config.macros.importTiddlers;
+	var txtSaveTiddler = wizard.getElement("txtSaveTiddler").value;
+	if(store.tiddlerExists(txtSaveTiddler)) {
+		if(!confirm(me.confirmOverwriteSaveTiddler.format([txtSaveTiddler])))
+			return;
+		store.suspendNotifications();
+		store.removeTiddler(txtSaveTiddler);
+		store.resumeNotifications();
+	}
+	var serverType = wizard.getValue("serverType");
+	var host = wizard.getValue("host");
+	var workspace = wizard.getValue("workspace");
+	var text = me.serverSaveTemplate.format([serverType,host,workspace]);
+	store.saveTiddler(txtSaveTiddler,txtSaveTiddler,text,me.serverSaveModifier,new Date(),["systemServer"]);
+};
+
+config.macros.importTiddlers.doImport = function(e)
+{
+	var me = config.macros.importTiddlers;
+	var wizard = new Wizard(this);
+	if(wizard.getElement("chkSave").checked)
+		me.saveServerTiddler(wizard);
+	var chkSync = wizard.getElement("chkSync").checked;
+	wizard.setValue("sync",chkSync);
+	var listView = wizard.getValue("listView");
+	var rowNames = ListView.getSelectedRows(listView);
+	var adaptor = wizard.getValue("adaptor");
+	var overwrite = [];
+	var t;
+	for(t=0; t<rowNames.length; t++) {
+		if(store.tiddlerExists(rowNames[t]))
+			overwrite.push(rowNames[t]);
+	}
+	if(overwrite.length > 0) {
+		if(!confirm(me.confirmOverwriteText.format([overwrite.join(", ")])))
+			return false;
+	}
+	wizard.addStep(me.step4Title.format([rowNames.length]),me.step4Html);
+	for(t=0; t<rowNames.length; t++) {
+		var link = document.createElement("div");
+		createTiddlyLink(link,rowNames[t],true);
+		var place = wizard.getElement("markReport");
+		place.parentNode.insertBefore(link,place);
+	}
+	wizard.setValue("remainingImports",rowNames.length);
+	wizard.setButtons([
+			{caption: me.cancelLabel, tooltip: me.cancelPrompt, onClick: me.onCancel}
+		],me.statusDoingImport);
+	var wizardContext = wizard.getValue("context");
+	var tiddlers = wizardContext ? wizardContext.tiddlers : [];
+	for(t=0; t<rowNames.length; t++) {
+		var context = {
+			allowSynchronous:true,
+			tiddler:tiddlers[tiddlers.findByField("title",rowNames[t])]
+		};
+		adaptor.getTiddler(rowNames[t],context,wizard,me.onGetTiddler);
+	}
+	return false;
+};
+
+config.macros.importTiddlers.onGetTiddler = function(context,wizard)
+{
+	var me = config.macros.importTiddlers;
+	if(!context.status)
+		displayMessage("Error in importTiddlers.onGetTiddler: " + context.statusText);
+	var tiddler = context.tiddler;
+	store.suspendNotifications();
+	store.saveTiddler(tiddler.title, tiddler.title, tiddler.text, tiddler.modifier, tiddler.modified, tiddler.tags, tiddler.fields, true, tiddler.created);
+	if(!wizard.getValue("sync")) {
+		store.setValue(tiddler.title,'server',null);
+	}
+	store.resumeNotifications();
+	if(!context.isSynchronous)
+		store.notify(tiddler.title,true);
+	var remainingImports = wizard.getValue("remainingImports")-1;
+	wizard.setValue("remainingImports",remainingImports);
+	if(remainingImports == 0) {
+		if(context.isSynchronous) {
+			store.notifyAll();
+			refreshDisplay();
+		}
+		wizard.setButtons([
+				{caption: me.doneLabel, tooltip: me.donePrompt, onClick: me.onClose}
+			],me.statusDoneImport);
+		autoSaveChanges();
+	}
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Lingo.js

@@ -0,0 +1,500 @@
+//--
+//-- Translateable strings
+//--
+
+// Strings in "double quotes" should be translated; strings in 'single quotes' should be left alone
+
+merge(config.options,{
+	txtUserName: "YourName"});
+
+merge(config.tasks,{
+	save: {text: "save", tooltip: "Save your changes to this TiddlyWiki"},
+	sync: {text: "sync", tooltip: "Synchronise changes with other TiddlyWiki files and servers", content: '<<sync>>'},
+	importTask: {text: "import", tooltip: "Import tiddlers and plugins from other TiddlyWiki files and servers", content: '<<importTiddlers>>'},
+	tweak: {text: "tweak", tooltip: "Tweak the appearance and behaviour of TiddlyWiki", content: '<<options>>'},
+	upgrade: {text: "upgrade", tooltip: "Upgrade TiddlyWiki core code", content: '<<upgrade>>'},
+	plugins: {text: "plugins", tooltip: "Manage installed plugins", content: '<<plugins>>'}
+});
+
+// Options that can be set in the options panel and/or cookies
+merge(config.optionsDesc,{
+	txtUserName: "Username for signing your edits",
+	chkRegExpSearch: "Enable regular expressions for searches",
+	chkCaseSensitiveSearch: "Case-sensitive searching",
+	chkIncrementalSearch: "Incremental key-by-key searching",
+	chkAnimate: "Enable animations",
+	chkSaveBackups: "Keep backup file when saving changes",
+	chkAutoSave: "Automatically save changes",
+	chkGenerateAnRssFeed: "Generate an RSS feed when saving changes",
+	chkSaveEmptyTemplate: "Generate an empty template when saving changes",
+	chkOpenInNewWindow: "Open external links in a new window",
+	chkToggleLinks: "Clicking on links to open tiddlers causes them to close",
+	chkHttpReadOnly: "Hide editing features when viewed over HTTP",
+	chkForceMinorUpdate: "Don't update modifier username and date when editing tiddlers",
+	chkConfirmDelete: "Require confirmation before deleting tiddlers",
+	chkInsertTabs: "Use the tab key to insert tab characters instead of moving between fields",
+	txtBackupFolder: "Name of folder to use for backups",
+	txtMaxEditRows: "Maximum number of rows in edit boxes",
+	txtTheme: "Name of the theme to use",
+	txtFileSystemCharSet: "Default character set for saving changes (Firefox/Mozilla only)"});
+
+merge(config.messages,{
+	customConfigError: "Problems were encountered loading plugins. See PluginManager for details",
+	pluginError: "Error: %0",
+	pluginDisabled: "Not executed because disabled via 'systemConfigDisable' tag",
+	pluginForced: "Executed because forced via 'systemConfigForce' tag",
+	pluginVersionError: "Not executed because this plugin needs a newer version of TiddlyWiki",
+	nothingSelected: "Nothing is selected. You must select one or more items first",
+	savedSnapshotError: "It appears that this TiddlyWiki has been incorrectly saved. Please see http://www.tiddlywiki.com/#Download for details",
+	subtitleUnknown: "(unknown)",
+	undefinedTiddlerToolTip: "The tiddler '%0' doesn't yet exist",
+	shadowedTiddlerToolTip: "The tiddler '%0' doesn't yet exist, but has a pre-defined shadow value",
+	tiddlerLinkTooltip: "%0 - %1, %2",
+	externalLinkTooltip: "External link to %0",
+	noTags: "There are no tagged tiddlers",
+	notFileUrlError: "You need to save this TiddlyWiki to a file before you can save changes",
+	cantSaveError: "It's not possible to save changes. Possible reasons include:\n- your browser doesn't support saving (Firefox, Internet Explorer, Safari and Opera all work if properly configured)\n- the pathname to your TiddlyWiki file contains illegal characters\n- the TiddlyWiki HTML file has been moved or renamed",
+	invalidFileError: "The original file '%0' does not appear to be a valid TiddlyWiki",
+	backupSaved: "Backup saved",
+	backupFailed: "Failed to save backup file",
+	rssSaved: "RSS feed saved",
+	rssFailed: "Failed to save RSS feed file",
+	emptySaved: "Empty template saved",
+	emptyFailed: "Failed to save empty template file",
+	mainSaved: "Main TiddlyWiki file saved",
+	mainFailed: "Failed to save main TiddlyWiki file. Your changes have not been saved",
+	macroError: "Error in macro <<%0>>",
+	macroErrorDetails: "Error while executing macro <<%0>>:\n%1",
+	missingMacro: "No such macro",
+	overwriteWarning: "A tiddler named '%0' already exists. Choose OK to overwrite it",
+	unsavedChangesWarning: "WARNING! There are unsaved changes in TiddlyWiki\n\nChoose OK to save\nChoose CANCEL to discard",
+	confirmExit: "--------------------------------\n\nThere are unsaved changes in TiddlyWiki. If you continue you will lose those changes\n\n--------------------------------",
+	saveInstructions: "SaveChanges",
+	unsupportedTWFormat: "Unsupported TiddlyWiki format '%0'",
+	tiddlerSaveError: "Error when saving tiddler '%0'",
+	tiddlerLoadError: "Error when loading tiddler '%0'",
+	wrongSaveFormat: "Cannot save with storage format '%0'. Using standard format for save.",
+	invalidFieldName: "Invalid field name %0",
+	fieldCannotBeChanged: "Field '%0' cannot be changed",
+	loadingMissingTiddler: "Attempting to retrieve the tiddler '%0' from the '%1' server at:\n\n'%2' in the workspace '%3'",
+	upgradeDone: "The upgrade to version %0 is now complete\n\nClick 'OK' to reload the newly upgraded TiddlyWiki",
+	invalidCookie: "Invalid cookie '%0'"});
+
+merge(config.messages.messageClose,{
+	text: "close",
+	tooltip: "close this message area"});
+
+config.messages.backstage = {
+	open: {text: "backstage", tooltip: "Open the backstage area to perform authoring and editing tasks"},
+	close: {text: "close", tooltip: "Close the backstage area"},
+	prompt: "backstage: ",
+	decal: {
+		edit: {text: "edit", tooltip: "Edit the tiddler '%0'"}
+	}
+};
+
+config.messages.listView = {
+	tiddlerTooltip: "Click for the full text of this tiddler",
+	previewUnavailable: "(preview not available)"
+};
+
+config.messages.dates.months = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November","December"];
+config.messages.dates.days = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+config.messages.dates.shortMonths = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+config.messages.dates.shortDays = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+// suffixes for dates, eg "1st","2nd","3rd"..."30th","31st"
+config.messages.dates.daySuffixes = ["st","nd","rd","th","th","th","th","th","th","th",
+		"th","th","th","th","th","th","th","th","th","th",
+		"st","nd","rd","th","th","th","th","th","th","th",
+		"st"];
+config.messages.dates.am = "am";
+config.messages.dates.pm = "pm";
+
+merge(config.messages.tiddlerPopup,{
+	});
+
+merge(config.views.wikified.tag,{
+	labelNoTags: "no tags",
+	labelTags: "tags: ",
+	openTag: "Open tag '%0'",
+	tooltip: "Show tiddlers tagged with '%0'",
+	openAllText: "Open all",
+	openAllTooltip: "Open all of these tiddlers",
+	popupNone: "No other tiddlers tagged with '%0'"});
+
+merge(config.views.wikified,{
+	defaultText: "The tiddler '%0' doesn't yet exist. Double-click to create it",
+	defaultModifier: "(missing)",
+	shadowModifier: "(built-in shadow tiddler)",
+	dateFormat: "DD MMM YYYY",
+	createdPrompt: "created"});
+
+merge(config.views.editor,{
+	tagPrompt: "Type tags separated with spaces, [[use double square brackets]] if necessary, or add existing",
+	defaultText: "Type the text for '%0'"});
+
+merge(config.views.editor.tagChooser,{
+	text: "tags",
+	tooltip: "Choose existing tags to add to this tiddler",
+	popupNone: "There are no tags defined",
+	tagTooltip: "Add the tag '%0'"});
+
+merge(config.messages,{
+	sizeTemplates:
+		[
+		{unit: 1024*1024*1024, template: "%0\u00a0GB"},
+		{unit: 1024*1024, template: "%0\u00a0MB"},
+		{unit: 1024, template: "%0\u00a0KB"},
+		{unit: 1, template: "%0\u00a0B"}
+		]});
+
+merge(config.macros.search,{
+	label: "search",
+	prompt: "Search this TiddlyWiki",
+	placeholder: "",
+	accessKey: "F",
+	successMsg: "%0 tiddlers found matching %1",
+	failureMsg: "No tiddlers found matching %0"});
+
+merge(config.macros.tagging,{
+	label: "tagging: ",
+	labelNotTag: "not tagging",
+	tooltip: "List of tiddlers tagged with '%0'"});
+
+merge(config.macros.timeline,{
+	dateFormat: "DD MMM YYYY"});
+
+merge(config.macros.allTags,{
+	tooltip: "Show tiddlers tagged with '%0'",
+	noTags: "There are no tagged tiddlers"});
+
+config.macros.list.all.prompt = "All tiddlers in alphabetical order";
+config.macros.list.missing.prompt = "Tiddlers that have links to them but are not defined";
+config.macros.list.orphans.prompt = "Tiddlers that are not linked to from any other tiddlers";
+config.macros.list.shadowed.prompt = "Tiddlers shadowed with default contents";
+config.macros.list.touched.prompt = "Tiddlers that have been modified locally";
+
+merge(config.macros.closeAll,{
+	label: "close all",
+	prompt: "Close all displayed tiddlers (except any that are being edited)"});
+
+merge(config.macros.permaview,{
+	label: "permaview",
+	prompt: "Link to an URL that retrieves all the currently displayed tiddlers"});
+
+merge(config.macros.saveChanges,{
+	label: "save changes",
+	prompt: "Save all tiddlers to create a new TiddlyWiki",
+	accessKey: "S"});
+
+merge(config.macros.newTiddler,{
+	label: "new tiddler",
+	prompt: "Create a new tiddler",
+	title: "New Tiddler",
+	accessKey: "N"});
+
+merge(config.macros.newJournal,{
+	label: "new journal",
+	prompt: "Create a new tiddler from the current date and time",
+	accessKey: "J"});
+
+merge(config.macros.options,{
+	wizardTitle: "Tweak advanced options",
+	step1Title: "These options are saved in cookies in your browser",
+	step1Html: "<input type='hidden' name='markList'></input><br><input type='checkbox' checked='false' name='chkUnknown'>Show unknown options</input>",
+	unknownDescription: "//(unknown)//",
+	listViewTemplate: {
+		columns: [
+			{name: 'Option', field: 'option', title: "Option", type: 'String'},
+			{name: 'Description', field: 'description', title: "Description", type: 'WikiText'},
+			{name: 'Name', field: 'name', title: "Name", type: 'String'}
+			],
+		rowClasses: [
+			{className: 'lowlight', field: 'lowlight'}
+			]}
+	});
+
+merge(config.macros.plugins,{
+	wizardTitle: "Manage plugins",
+	step1Title: "Currently loaded plugins",
+	step1Html: "<input type='hidden' name='markList'></input>", // DO NOT TRANSLATE
+	skippedText: "(This plugin has not been executed because it was added since startup)",
+	noPluginText: "There are no plugins installed",
+	confirmDeleteText: "Are you sure you want to delete these plugins:\n\n%0",
+	removeLabel: "remove systemConfig tag",
+	removePrompt: "Remove systemConfig tag",
+	deleteLabel: "delete",
+	deletePrompt: "Delete these tiddlers forever",
+	listViewTemplate: {
+		columns: [
+			{name: 'Selected', field: 'Selected', rowName: 'title', type: 'Selector'},
+			{name: 'Tiddler', field: 'tiddler', title: "Tiddler", type: 'Tiddler'},
+			{name: 'Description', field: 'Description', title: "Description", type: 'String'},
+			{name: 'Version', field: 'Version', title: "Version", type: 'String'},
+			{name: 'Size', field: 'size', tiddlerLink: 'size', title: "Size", type: 'Size'},
+			{name: 'Forced', field: 'forced', title: "Forced", tag: 'systemConfigForce', type: 'TagCheckbox'},
+			{name: 'Disabled', field: 'disabled', title: "Disabled", tag: 'systemConfigDisable', type: 'TagCheckbox'},
+			{name: 'Executed', field: 'executed', title: "Loaded", type: 'Boolean', trueText: "Yes", falseText: "No"},
+			{name: 'Startup Time', field: 'startupTime', title: "Startup Time", type: 'String'},
+			{name: 'Error', field: 'error', title: "Status", type: 'Boolean', trueText: "Error", falseText: "OK"},
+			{name: 'Log', field: 'log', title: "Log", type: 'StringList'}
+			],
+		rowClasses: [
+			{className: 'error', field: 'error'},
+			{className: 'warning', field: 'warning'}
+			]},
+	listViewTemplateReadOnly: {
+		columns: [
+			{name: 'Tiddler', field: 'tiddler', title: "Tiddler", type: 'Tiddler'},
+			{name: 'Description', field: 'Description', title: "Description", type: 'String'},
+			{name: 'Version', field: 'Version', title: "Version", type: 'String'},
+			{name: 'Size', field: 'size', tiddlerLink: 'size', title: "Size", type: 'Size'},
+			{name: 'Executed', field: 'executed', title: "Loaded", type: 'Boolean', trueText: "Yes", falseText: "No"},
+			{name: 'Startup Time', field: 'startupTime', title: "Startup Time", type: 'String'},
+			{name: 'Error', field: 'error', title: "Status", type: 'Boolean', trueText: "Error", falseText: "OK"},
+			{name: 'Log', field: 'log', title: "Log", type: 'StringList'}
+			],
+		rowClasses: [
+			{className: 'error', field: 'error'},
+			{className: 'warning', field: 'warning'}
+			]}
+	});
+
+merge(config.macros.toolbar,{
+	moreLabel: "more",
+	morePrompt: "Show additional commands",
+	lessLabel: "less",
+	lessPrompt: "Hide additional commands",
+	separator: "|"
+	});
+
+merge(config.macros.refreshDisplay,{
+	label: "refresh",
+	prompt: "Redraw the entire TiddlyWiki display"
+	});
+
+merge(config.macros.importTiddlers,{
+	readOnlyWarning: "You cannot import into a read-only TiddlyWiki file. Try opening it from a file:// URL",
+	wizardTitle: "Import tiddlers from another file or server",
+	step1Title: "Step 1: Locate the server or TiddlyWiki file",
+	step1Html: "Specify the type of the server: <select name='selTypes'><option value=''>Choose...</option></select><br>Enter the URL or pathname here: <input type='text' size=50 name='txtPath'><br>...or browse for a file: <input type='file' size=50 name='txtBrowse'><br><hr>...or select a pre-defined feed: <select name='selFeeds'><option value=''>Choose...</option></select>",
+	openLabel: "open",
+	openPrompt: "Open the connection to this file or server",
+	statusOpenHost: "Opening the host",
+	statusGetWorkspaceList: "Getting the list of available workspaces",
+	step2Title: "Step 2: Choose the workspace",
+	step2Html: "Enter a workspace name: <input type='text' size=50 name='txtWorkspace'><br>...or select a workspace: <select name='selWorkspace'><option value=''>Choose...</option></select>",
+	cancelLabel: "cancel",
+	cancelPrompt: "Cancel this import",
+	statusOpenWorkspace: "Opening the workspace",
+	statusGetTiddlerList: "Getting the list of available tiddlers",
+	errorGettingTiddlerList: "Error getting list of tiddlers, click Cancel to try again",
+	errorGettingTiddlerListHttp404: "Error retrieving tiddlers from url, please ensure the url exists. Click Cancel to try again.",
+	errorGettingTiddlerListHttp: "Error retrieving tiddlers from url, please ensure this url exists and is <a href='http://enable-cors.org/'>CORS</a> enabled",
+	errorGettingTiddlerListFile: "Error retrieving tiddlers from local file, please make sure the file is in the same directory as your TiddlyWiki. Click Cancel to try again.",
+	step3Title: "Step 3: Choose the tiddlers to import",
+	step3Html: "<input type='hidden' name='markList'></input><br><input type='checkbox' checked='true' name='chkSync'>Keep these tiddlers linked to this server so that you can synchronise subsequent changes</input><br><input type='checkbox' name='chkSave'>Save the details of this server in a 'systemServer' tiddler called:</input> <input type='text' size=25 name='txtSaveTiddler'>",
+	importLabel: "import",
+	importPrompt: "Import these tiddlers",
+	confirmOverwriteText: "Are you sure you want to overwrite these tiddlers:\n\n%0",
+	step4Title: "Step 4: Importing %0 tiddler(s)",
+	step4Html: "<input type='hidden' name='markReport'></input>", // DO NOT TRANSLATE
+	doneLabel: "done",
+	donePrompt: "Close this wizard",
+	statusDoingImport: "Importing tiddlers",
+	statusDoneImport: "All tiddlers imported",
+	systemServerNamePattern: "%2 on %1",
+	systemServerNamePatternNoWorkspace: "%1",
+	confirmOverwriteSaveTiddler: "The tiddler '%0' already exists. Click 'OK' to overwrite it with the details of this server, or 'Cancel' to leave it unchanged",
+	serverSaveTemplate: "|''Type:''|%0|\n|''URL:''|%1|\n|''Workspace:''|%2|\n\nThis tiddler was automatically created to record the details of this server",
+	serverSaveModifier: "(System)",
+	listViewTemplate: {
+		columns: [
+			{name: 'Selected', field: 'Selected', rowName: 'title', type: 'Selector'},
+			{name: 'Tiddler', field: 'tiddler', title: "Tiddler", type: 'Tiddler'},
+			{name: 'Size', field: 'size', tiddlerLink: 'size', title: "Size", type: 'Size'},
+			{name: 'Tags', field: 'tags', title: "Tags", type: 'Tags'}
+			],
+		rowClasses: [
+			]}
+	});
+
+merge(config.macros.upgrade,{
+	wizardTitle: "Upgrade TiddlyWiki core code",
+	step1Title: "Update or repair this TiddlyWiki to the latest release",
+	step1Html: "You are about to upgrade to the latest release of the TiddlyWiki core code (from <a href='%0' class='externalLink' target='_blank'>%1</a>). Your content will be preserved across the upgrade.<br><br>Note that core upgrades have been known to interfere with older plugins. If you run into problems with the upgraded file, see <a href='http://www.tiddlywiki.org/wiki/CoreUpgrades' class='externalLink' target='_blank'>http://www.tiddlywiki.org/wiki/CoreUpgrades</a>",
+	errorCantUpgrade: "Unable to upgrade this TiddlyWiki. You can only perform upgrades on TiddlyWiki files stored locally",
+	errorNotSaved: "You must save changes before you can perform an upgrade",
+	step2Title: "Confirm the upgrade details",
+	step2Html_downgrade: "You are about to downgrade to TiddlyWiki version %0 from %1.<br><br>Downgrading to an earlier version of the core code is not recommended",
+	step2Html_restore: "This TiddlyWiki appears to be already using the latest version of the core code (%0).<br><br>You can continue to upgrade anyway to ensure that the core code hasn't been corrupted or damaged",
+	step2Html_upgrade: "You are about to upgrade to TiddlyWiki version %0 from %1",
+	upgradeLabel: "upgrade",
+	upgradePrompt: "Prepare for the upgrade process",
+	statusPreparingBackup: "Preparing backup",
+	statusSavingBackup: "Saving backup file",
+	errorSavingBackup: "There was a problem saving the backup file",
+	statusLoadingCore: "Loading core code",
+	errorLoadingCore: "Error loading the core code",
+	errorCoreFormat: "Error with the new core code",
+	statusSavingCore: "Saving the new core code",
+	statusReloadingCore: "Reloading the new core code",
+	startLabel: "start",
+	startPrompt: "Start the upgrade process",
+	cancelLabel: "cancel",
+	cancelPrompt: "Cancel the upgrade process",
+	step3Title: "Upgrade cancelled",
+	step3Html: "You have cancelled the upgrade process"
+	});
+
+merge(config.macros.sync,{
+	listViewTemplate: {
+		columns: [
+			{name: 'Selected', field: 'selected', rowName: 'title', type: 'Selector'},
+			{name: 'Tiddler', field: 'tiddler', title: "Tiddler", type: 'Tiddler'},
+			{name: 'Server Type', field: 'serverType', title: "Server type", type: 'String'},
+			{name: 'Server Host', field: 'serverHost', title: "Server host", type: 'String'},
+			{name: 'Server Workspace', field: 'serverWorkspace', title: "Server workspace", type: 'String'},
+			{name: 'Status', field: 'status', title: "Synchronisation status", type: 'String'},
+			{name: 'Server URL', field: 'serverUrl', title: "Server URL", text: "View", type: 'Link'}
+			],
+		rowClasses: [
+			],
+		buttons: [
+			{caption: "Sync these tiddlers", name: 'sync'}
+			]},
+	wizardTitle: "Synchronize with external servers and files",
+	step1Title: "Choose the tiddlers you want to synchronize",
+	step1Html: "<input type='hidden' name='markList'></input>", // DO NOT TRANSLATE
+	syncLabel: "sync",
+	syncPrompt: "Sync these tiddlers",
+	hasChanged: "Changed while unplugged",
+	hasNotChanged: "Unchanged while unplugged",
+	syncStatusList: {
+		none: {text: "...", display:'none', className:'notChanged'},
+		changedServer: {text: "Changed on server", display:null, className:'changedServer'},
+		changedLocally: {text: "Changed while unplugged", display:null, className:'changedLocally'},
+		changedBoth: {text: "Changed while unplugged and on server", display:null, className:'changedBoth'},
+		notFound: {text: "Not found on server", display:null, className:'notFound'},
+		putToServer: {text: "Saved update on server", display:null, className:'putToServer'},
+		gotFromServer: {text: "Retrieved update from server", display:null, className:'gotFromServer'}
+		}
+	});
+
+merge(config.macros.annotations,{
+	});
+
+merge(config.commands.closeTiddler,{
+	text: "close",
+	tooltip: "Close this tiddler"});
+
+merge(config.commands.closeOthers,{
+	text: "close others",
+	tooltip: "Close all other tiddlers"});
+
+merge(config.commands.editTiddler,{
+	text: "edit",
+	tooltip: "Edit this tiddler",
+	readOnlyText: "view",
+	readOnlyTooltip: "View the source of this tiddler"});
+
+merge(config.commands.saveTiddler,{
+	text: "done",
+	tooltip: "Save changes to this tiddler"});
+
+merge(config.commands.cancelTiddler,{
+	text: "cancel",
+	tooltip: "Undo changes to this tiddler",
+	warning: "Are you sure you want to abandon your changes to '%0'?",
+	readOnlyText: "done",
+	readOnlyTooltip: "View this tiddler normally"});
+
+merge(config.commands.deleteTiddler,{
+	text: "delete",
+	tooltip: "Delete this tiddler",
+	warning: "Are you sure you want to delete '%0'?"});
+
+merge(config.commands.permalink,{
+	text: "permalink",
+	tooltip: "Permalink for this tiddler"});
+
+merge(config.commands.references,{
+	text: "references",
+	tooltip: "Show tiddlers that link to this one",
+	popupNone: "No references"});
+
+merge(config.commands.jump,{
+	text: "jump",
+	tooltip: "Jump to another open tiddler"});
+
+merge(config.commands.syncing,{
+	text: "syncing",
+	tooltip: "Control synchronisation of this tiddler with a server or external file",
+	currentlySyncing: "<div>Currently syncing via <span class='popupHighlight'>'%0'</span> to:</"+"div><div>host: <span class='popupHighlight'>%1</span></"+"div><div>workspace: <span class='popupHighlight'>%2</span></"+"div>", // Note escaping of closing <div> tag
+	notCurrentlySyncing: "Not currently syncing",
+	captionUnSync: "Stop synchronising this tiddler",
+	chooseServer: "Synchronise this tiddler with another server:",
+	currServerMarker: "\u25cf ",
+	notCurrServerMarker: "  "});
+
+merge(config.commands.fields,{
+	text: "fields",
+	tooltip: "Show the extended fields of this tiddler",
+	emptyText: "There are no extended fields for this tiddler",
+	listViewTemplate: {
+		columns: [
+			{name: 'Field', field: 'field', title: "Field", type: 'String'},
+			{name: 'Value', field: 'value', title: "Value", type: 'String'}
+			],
+		rowClasses: [
+			],
+		buttons: [
+			]}});
+
+merge(config.shadowTiddlers,{
+	DefaultTiddlers: "[[GettingStarted]]",
+	MainMenu: "[[GettingStarted]]",
+	SiteTitle: "My TiddlyWiki",
+	SiteSubtitle: "a reusable non-linear personal web notebook",
+	SiteUrl: "",
+	SideBarOptions: '<<search>><<closeAll>><<permaview>><<newTiddler>><<newJournal "DD MMM YYYY" "journal">><<saveChanges>><<slider chkSliderOptionsPanel OptionsPanel "options \u00bb" "Change TiddlyWiki advanced options">>',
+	SideBarTabs: '<<tabs txtMainTab "Timeline" "Timeline" TabTimeline "All" "All tiddlers" TabAll "Tags" "All tags" TabTags "More" "More lists" TabMore>>',
+	TabMore: '<<tabs txtMoreTab "Missing" "Missing tiddlers" TabMoreMissing "Orphans" "Orphaned tiddlers" TabMoreOrphans "Shadowed" "Shadowed tiddlers" TabMoreShadowed>>'
+	});
+
+merge(config.annotations,{
+	AdvancedOptions: "This shadow tiddler provides access to several advanced options",
+	ColorPalette: "These values in this shadow tiddler determine the colour scheme of the ~TiddlyWiki user interface",
+	DefaultTiddlers: "The tiddlers listed in this shadow tiddler will be automatically displayed when ~TiddlyWiki starts up",
+	EditTemplate: "The HTML template in this shadow tiddler determines how tiddlers look while they are being edited",
+	GettingStarted: "This shadow tiddler provides basic usage instructions",
+	ImportTiddlers: "This shadow tiddler provides access to importing tiddlers",
+	MainMenu: "This shadow tiddler is used as the contents of the main menu in the left-hand column of the screen",
+	MarkupPreHead: "This tiddler is inserted at the top of the <head> section of the TiddlyWiki HTML file",
+	MarkupPostHead: "This tiddler is inserted at the bottom of the <head> section of the TiddlyWiki HTML file",
+	MarkupPreBody: "This tiddler is inserted at the top of the <body> section of the TiddlyWiki HTML file",
+	MarkupPostBody: "This tiddler is inserted at the end of the <body> section of the TiddlyWiki HTML file immediately after the script block",
+	OptionsPanel: "This shadow tiddler is used as the contents of the options panel slider in the right-hand sidebar",
+	PageTemplate: "The HTML template in this shadow tiddler determines the overall ~TiddlyWiki layout",
+	PluginManager: "This shadow tiddler provides access to the plugin manager",
+	SideBarOptions: "This shadow tiddler is used as the contents of the option panel in the right-hand sidebar",
+	SideBarTabs: "This shadow tiddler is used as the contents of the tabs panel in the right-hand sidebar",
+	SiteSubtitle: "This shadow tiddler is used as the second part of the page title",
+	SiteTitle: "This shadow tiddler is used as the first part of the page title",
+	SiteUrl: "This shadow tiddler should be set to the full target URL for publication",
+	StyleSheetColors: "This shadow tiddler contains CSS definitions related to the color of page elements. ''DO NOT EDIT THIS TIDDLER'', instead make your changes in the StyleSheet shadow tiddler",
+	StyleSheet: "This tiddler can contain custom CSS definitions",
+	StyleSheetLayout: "This shadow tiddler contains CSS definitions related to the layout of page elements. ''DO NOT EDIT THIS TIDDLER'', instead make your changes in the StyleSheet shadow tiddler",
+	StyleSheetLocale: "This shadow tiddler contains CSS definitions related to the translation locale",
+	StyleSheetPrint: "This shadow tiddler contains CSS definitions for printing",
+	SystemSettings: "This tiddler is used to store configuration options for this TiddlyWiki document",
+	TabAll: "This shadow tiddler contains the contents of the 'All' tab in the right-hand sidebar",
+	TabMore: "This shadow tiddler contains the contents of the 'More' tab in the right-hand sidebar",
+	TabMoreMissing: "This shadow tiddler contains the contents of the 'Missing' tab in the right-hand sidebar",
+	TabMoreOrphans: "This shadow tiddler contains the contents of the 'Orphans' tab in the right-hand sidebar",
+	TabMoreShadowed: "This shadow tiddler contains the contents of the 'Shadowed' tab in the right-hand sidebar",
+	TabTags: "This shadow tiddler contains the contents of the 'Tags' tab in the right-hand sidebar",
+	TabTimeline: "This shadow tiddler contains the contents of the 'Timeline' tab in the right-hand sidebar",
+	ToolbarCommands: "This shadow tiddler determines which commands are shown in tiddler toolbars",
+	ViewTemplate: "The HTML template in this shadow tiddler determines how tiddlers look"
+	});

test/tiddlywiki.2.6.5/source/tiddlywiki/js/ListView.js

@@ -0,0 +1,275 @@
+//--
+//-- ListView gadget
+//--
+
+var ListView = {};
+
+// Create a listview
+//#   place - where in the DOM tree to insert the listview
+//#   listObject - array of objects to be included in the listview
+//#   listTemplate - template for the listview
+//#   callback - callback for a command being selected
+//#   className - optional classname for the <table> element
+ListView.create = function(place,listObject,listTemplate,callback,className)
+{
+	var table = createTiddlyElement(place,"table",null,className || "listView twtable");
+	var thead = createTiddlyElement(table,"thead");
+	var t,r = createTiddlyElement(thead,"tr");
+	for(t=0; t<listTemplate.columns.length; t++) {
+		var columnTemplate = listTemplate.columns[t];
+		var c = createTiddlyElement(r,"th");
+		var colType = ListView.columnTypes[columnTemplate.type];
+		if(colType && colType.createHeader) {
+			colType.createHeader(c,columnTemplate,t);
+			if(columnTemplate.className)
+				jQuery(c).addClass(columnTemplate.className);
+		}
+	}
+	var rc,tbody = createTiddlyElement(table,"tbody");
+	for(rc=0; rc<listObject.length; rc++) {
+		var rowObject = listObject[rc];
+		r = createTiddlyElement(tbody,"tr");
+		for(c=0; c<listTemplate.rowClasses.length; c++) {
+			if(rowObject[listTemplate.rowClasses[c].field])
+				jQuery(r).addClass(listTemplate.rowClasses[c].className);
+		}
+		rowObject.rowElement = r;
+		rowObject.colElements = {};
+		var cc;
+		for(cc=0; cc<listTemplate.columns.length; cc++) {
+			c = createTiddlyElement(r,"td");
+			columnTemplate = listTemplate.columns[cc];
+			var field = columnTemplate.field;
+			colType = ListView.columnTypes[columnTemplate.type];
+			if(colType && colType.createItem) {
+				colType.createItem(c,rowObject,field,columnTemplate,cc,rc);
+				if(columnTemplate.className)
+					jQuery(c).addClass(columnTemplate.className);
+			}
+			rowObject.colElements[field] = c;
+		}
+	}
+	if(callback && listTemplate.actions)
+		createTiddlyDropDown(place,ListView.getCommandHandler(callback),listTemplate.actions);
+	if(callback && listTemplate.buttons) {
+		for(t=0; t<listTemplate.buttons.length; t++) {
+			var a = listTemplate.buttons[t];
+			if(a && a.name != "")
+				createTiddlyButton(place,a.caption,null,ListView.getCommandHandler(callback,a.name,a.allowEmptySelection));
+		}
+	}
+	return table;
+};
+
+ListView.getCommandHandler = function(callback,name,allowEmptySelection)
+{
+	return function(e) {
+		var view = findRelated(this,"TABLE",null,"previousSibling");
+		var tiddlers = [];
+		ListView.forEachSelector(view,function(e,rowName) {
+					if(e.checked)
+						tiddlers.push(rowName);
+					});
+		if(tiddlers.length == 0 && !allowEmptySelection) {
+			alert(config.messages.nothingSelected);
+		} else {
+			if(this.nodeName.toLowerCase() == "select") {
+				callback(view,this.value,tiddlers);
+				this.selectedIndex = 0;
+			} else {
+				callback(view,name,tiddlers);
+			}
+		}
+	};
+};
+
+// Invoke a callback for each selector checkbox in the listview
+//#   view - <table> element of listView
+//#   callback(checkboxElement,rowName)
+//#     where
+//#       checkboxElement - DOM element of checkbox
+//#       rowName - name of this row as assigned by the column template
+//#   result: true if at least one selector was checked
+ListView.forEachSelector = function(view,callback)
+{
+	var checkboxes = view.getElementsByTagName("input");
+	var t,hadOne = false;
+	for(t=0; t<checkboxes.length; t++) {
+		var cb = checkboxes[t];
+		if(cb.getAttribute("type") == "checkbox") {
+			var rn = cb.getAttribute("rowName");
+			if(rn) {
+				callback(cb,rn);
+				hadOne = true;
+			}
+		}
+	}
+	return hadOne;
+};
+
+ListView.getSelectedRows = function(view)
+{
+	var rowNames = [];
+	ListView.forEachSelector(view,function(e,rowName) {
+				if(e.checked)
+					rowNames.push(rowName);
+				});
+	return rowNames;
+};
+
+ListView.columnTypes = {};
+
+ListView.columnTypes.String = {
+	createHeader: function(place,columnTemplate,col)
+		{
+			createTiddlyText(place,columnTemplate.title);
+		},
+	createItem: function(place,listObject,field,columnTemplate,col,row)
+		{
+			var v = listObject[field];
+			if(v != undefined)
+				createTiddlyText(place,v);
+		}
+};
+
+ListView.columnTypes.WikiText = {
+	createHeader: ListView.columnTypes.String.createHeader,
+	createItem: function(place,listObject,field,columnTemplate,col,row)
+		{
+			var v = listObject[field];
+			if(v != undefined)
+				wikify(v,place,null,null);
+		}
+};
+
+ListView.columnTypes.Tiddler = {
+	createHeader: ListView.columnTypes.String.createHeader,
+	createItem: function(place,listObject,field,columnTemplate,col,row)
+		{
+			var v = listObject[field];
+			if(v != undefined && v.title)
+				createTiddlyPopup(place,v.title,config.messages.listView.tiddlerTooltip,v);
+		}
+};
+
+ListView.columnTypes.Size = {
+	createHeader: ListView.columnTypes.String.createHeader,
+	createItem: function(place,listObject,field,columnTemplate,col,row)
+		{
+			var msg = config.messages.sizeTemplates;
+			var v = listObject[field];
+			if(v != undefined) {
+				var t = 0;
+				while(t<msg.length-1 && v<msg[t].unit)
+					t++;
+				createTiddlyText(place,msg[t].template.format([Math.round(v/msg[t].unit)]));
+			}
+		}
+};
+
+ListView.columnTypes.Link = {
+	createHeader: ListView.columnTypes.String.createHeader,
+	createItem: function(place,listObject,field,columnTemplate,col,row)
+		{
+			var v = listObject[field];
+			var c = columnTemplate.text;
+			if(v != undefined)
+				createExternalLink(place,v,c || v);
+		}
+};
+
+ListView.columnTypes.Date = {
+	createHeader: ListView.columnTypes.String.createHeader,
+	createItem: function(place,listObject,field,columnTemplate,col,row)
+		{
+			var v = listObject[field];
+			if(v != undefined)
+				createTiddlyText(place,v.formatString(columnTemplate.dateFormat));
+		}
+};
+
+ListView.columnTypes.StringList = {
+	createHeader: ListView.columnTypes.String.createHeader,
+	createItem: function(place,listObject,field,columnTemplate,col,row)
+		{
+			var v = listObject[field];
+			if(v != undefined) {
+				var t;
+				for(t=0; t<v.length; t++) {
+					createTiddlyText(place,v[t]);
+					createTiddlyElement(place,"br");
+				}
+			}
+		}
+};
+
+ListView.columnTypes.Selector = {
+	createHeader: function(place,columnTemplate,col)
+		{
+			createTiddlyCheckbox(place,null,false,this.onHeaderChange);
+		},
+	createItem: function(place,listObject,field,columnTemplate,col,row)
+		{
+			var e = createTiddlyCheckbox(place,null,listObject[field],null);
+			e.setAttribute("rowName",listObject[columnTemplate.rowName]);
+		},
+	onHeaderChange: function(e)
+		{
+			var state = this.checked;
+			var view = findRelated(this,"TABLE");
+			if(!view)
+				return;
+			ListView.forEachSelector(view,function(e,rowName) {
+								e.checked = state;
+							});
+		}
+};
+
+ListView.columnTypes.Tags = {
+	createHeader: ListView.columnTypes.String.createHeader,
+	createItem: function(place,listObject,field,columnTemplate,col,row)
+		{
+			var tags = listObject[field];
+			createTiddlyText(place,String.encodeTiddlyLinkList(tags));
+		}
+};
+
+ListView.columnTypes.Boolean = {
+	createHeader: ListView.columnTypes.String.createHeader,
+	createItem: function(place,listObject,field,columnTemplate,col,row)
+		{
+			if(listObject[field] == true)
+				createTiddlyText(place,columnTemplate.trueText);
+			if(listObject[field] == false)
+				createTiddlyText(place,columnTemplate.falseText);
+		}
+};
+
+ListView.columnTypes.TagCheckbox = {
+	createHeader: ListView.columnTypes.String.createHeader,
+	createItem: function(place,listObject,field,columnTemplate,col,row)
+		{
+			var e = createTiddlyCheckbox(place,null,listObject[field],this.onChange);
+			e.setAttribute("tiddler",listObject.title);
+			e.setAttribute("tag",columnTemplate.tag);
+		},
+	onChange : function(e)
+		{
+			var tag = this.getAttribute("tag");
+			var tiddler = this.getAttribute("tiddler");
+			store.setTiddlerTag(tiddler,this.checked,tag);
+		}
+};
+
+ListView.columnTypes.TiddlerLink = {
+	createHeader: ListView.columnTypes.String.createHeader,
+	createItem: function(place,listObject,field,columnTemplate,col,row)
+		{
+			var v = listObject[field];
+			if(v != undefined) {
+				var link = createTiddlyLink(place,listObject[columnTemplate.tiddlerLink],false,null);
+				createTiddlyText(link,listObject[field]);
+			}
+		}
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/LoaderSaver.js

@@ -0,0 +1,59 @@
+//--
+//-- LoaderBase and SaverBase
+//--
+
+//# LoaderBase: A (abstract) storage loader that loads the tiddlers from a list of HTML elements.
+//# The format of the elements is defined by subclasses of this loader through the internalizeTiddler implementation.
+//# Subclasses must implement:
+//#			function getTitle(store,node)
+//#			function internalizeTiddler(store,tiddler,title,node)
+//#
+//# store must implement:
+//#			function createTiddler(title)
+function LoaderBase() {}
+
+LoaderBase.prototype.loadTiddler = function(store,node,tiddlers)
+{
+	var title = this.getTitle(store,node);
+	if(safeMode && store.isShadowTiddler(title))
+		return;
+	if(title) {
+		var tiddler = store.createTiddler(title);
+		this.internalizeTiddler(store,tiddler,title,node);
+		tiddlers.push(tiddler);
+	}
+};
+
+LoaderBase.prototype.loadTiddlers = function(store,nodes)
+{
+	var t,tiddlers = [];
+	for(t = 0; t < nodes.length; t++) {
+		try {
+			this.loadTiddler(store,nodes[t],tiddlers);
+		} catch(ex) {
+			showException(ex,config.messages.tiddlerLoadError.format([this.getTitle(store,nodes[t])]));
+		}
+	}
+	return tiddlers;
+};
+
+//# SaverBase: a (abstract) storage saver that externalizes all tiddlers into a string,
+//# with every tiddler individually externalized (using this.externalizeTiddler) and joined with newlines
+//# Subclasses must implement:
+//#			function externalizeTiddler(store,tiddler)
+//#
+//# store must implement:
+//#			function getTiddlers(sortByFieldName)
+function SaverBase() {}
+
+SaverBase.prototype.externalize = function(store)
+{
+	var results = [];
+	var t,tiddlers = store.getTiddlers("title");
+	for(t = 0; t < tiddlers.length; t++) {
+		if(!tiddlers[t].doNotSave())
+			results.push(this.externalizeTiddler(store, tiddlers[t]));
+	}
+	return results.join("\n");
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Macros.js

@@ -0,0 +1,567 @@
+//--
+//-- Macro definitions
+//--
+
+function invokeMacro(place,macro,params,wikifier,tiddler)
+{
+	try {
+		var m = config.macros[macro];
+		if(m && m.handler) {
+			var tiddlerElem = story.findContainingTiddler(place);
+			//# Provide context for evaluated macro parameters (eg <<myMacro {{tiddler.title}}>>)
+			window.tiddler = tiddlerElem ? store.getTiddler(tiddlerElem.getAttribute("tiddler")) : null;
+			window.place = place;
+			var allowEval = true;
+			if(config.evaluateMacroParameters=="system") {
+				if(!tiddler || tiddler.tags.indexOf("systemAllowEval") == -1) {
+					allowEval = false;
+				}
+			}
+			m.handler(place,macro,m.noPreParse?null:params.readMacroParams(!allowEval),wikifier,params,tiddler);
+		} else {
+			createTiddlyError(place,config.messages.macroError.format([macro]),config.messages.macroErrorDetails.format([macro,config.messages.missingMacro]));
+		}
+	} catch(ex) {
+		createTiddlyError(place,config.messages.macroError.format([macro]),config.messages.macroErrorDetails.format([macro,ex.toString()]));
+	}
+}
+
+config.macros.version.handler = function(place)
+{
+	jQuery("<span/>").text(formatVersion()).appendTo(place);
+};
+
+config.macros.today.handler = function(place,macroName,params)
+{
+	var now = new Date();
+	var text = params[0] ? now.formatString(params[0].trim()) : now.toLocaleString();
+	jQuery("<span/>").text(text).appendTo(place);
+};
+
+config.macros.list.template = "<<view title link>>";
+config.macros.list.handler = function(place,macroName,params,wikifier,paramString)
+{
+	var list = document.createElement("ul");
+	jQuery(list).attr({ refresh: "macro", macroName: macroName }).data("params", paramString);
+	place.appendChild(list);
+	this.refresh(list);
+};
+
+config.macros.list.refresh = function(list) {
+	var paramString = jQuery(list).data("params");
+	var params = paramString.readMacroParams();
+	var args = paramString.parseParams("anon", null, null)[0];
+	var type = args.anon ? args.anon[0] : "all";
+	jQuery(list).empty().addClass("list list-" + type);
+	var template = args.template ? store.getTiddlerText(args.template[0]) : false;
+	if(!template) {
+		template = config.macros.list.template;
+	}
+	if(this[type].prompt)
+		createTiddlyElement(list,"li",null,"listTitle",this[type].prompt);
+	var results;
+	if(this[type].handler)
+		results = this[type].handler(params);
+	var t;
+	for(t = 0; t < results.length; t++) {
+		var li = document.createElement("li");
+		list.appendChild(li);
+		var tiddler = results[t];
+		if(typeof(tiddler) == 'string') { // deal with missing etc..
+				tiddler = store.getTiddler(tiddler) || new Tiddler(tiddler);
+		}
+		wikify(template, li, null, tiddler);
+	}
+	if(results.length === 0 && args.emptyMessage) {
+		jQuery(list).addClass("emptyList");
+		jQuery("<li />").text(args.emptyMessage[0]).appendTo(list);
+	}
+};
+
+config.macros.list.all.handler = function(params)
+{
+	return store.reverseLookup("tags","excludeLists",false,"title");
+};
+
+config.macros.list.missing.handler = function(params)
+{
+	return store.getMissingLinks();
+};
+
+config.macros.list.orphans.handler = function(params)
+{
+	return store.getOrphans();
+};
+
+config.macros.list.shadowed.handler = function(params)
+{
+	return store.getShadowed();
+};
+
+config.macros.list.touched.handler = function(params)
+{
+	return store.getTouched();
+};
+
+config.macros.list.filter.handler = function(params)
+{
+	var filter = params[1];
+	var results = [];
+	if(filter) {
+		var tiddlers = store.filterTiddlers(filter);
+		var t;
+		for(t=0; t<tiddlers.length; t++)
+			results.push(tiddlers[t].title);
+	}
+	return results;
+};
+
+config.macros.allTags.handler = function(place,macroName,params)
+{
+	var tags = store.getTags(params[0]);
+	var ul = createTiddlyElement(place,"ul");
+	if(tags.length == 0)
+		createTiddlyElement(ul,"li",null,"listTitle",this.noTags);
+	var t;
+	for(t=0; t<tags.length; t++) {
+		var title = tags[t][0];
+		var info = getTiddlyLinkInfo(title);
+		var li = createTiddlyElement(ul,"li");
+		var btn = createTiddlyButton(li,title + " (" + tags[t][1] + ")",this.tooltip.format([title]),onClickTag,info.classes);
+		btn.setAttribute("tag",title);
+		btn.setAttribute("refresh","link");
+		btn.setAttribute("tiddlyLink",title);
+		if(params[1]) {
+			btn.setAttribute("sortby",params[1]);
+		}
+	}
+};
+
+var macro = config.macros.timeline;
+merge(macro, {
+	handler: function(place,macroName,params, wikifier, paramString, tiddler) {
+		var container = jQuery("<div />").attr("params", paramString).
+			attr("macroName", macroName).appendTo(place)[0];
+		macro.refresh(container);
+	},
+	refresh: function(container) {
+		jQuery(container).attr("refresh", "macro").empty();
+		var paramString = jQuery(container).attr("params");
+		var args = paramString.parseParams("anon", null, null)[0];
+		var params = args.anon || [];
+
+		var field = params[0] || "modified";
+		var dateFormat = params[2] || this.dateFormat;
+		var groupTemplate = macro.groupTemplate.format(field, dateFormat);
+		groupTemplate = args.groupTemplate ? store.getTiddlerText(args.groupTemplate[0]) || groupTemplate :
+			groupTemplate;
+
+		var itemTemplate = macro.itemTemplate;
+		itemTemplate = args.template ? store.getTiddlerText(args.template[0]) || itemTemplate :
+			itemTemplate;
+
+		var tiddlers = args.filter ? store.sortTiddlers(store.filterTiddlers(args.filter[0]), field) :
+			store.reverseLookup("tags", "excludeLists", false, field);
+		var lastGroup = "", ul;
+		var last = params[1] ? tiddlers.length-Math.min(tiddlers.length,parseInt(params[1],10)) : 0;
+		var t;
+		for(t=tiddlers.length-1; t>=last; t--) {
+			var tiddler = tiddlers[t];
+			var theGroup = wikifyPlainText(groupTemplate,0,tiddler);
+			if(typeof(ul) == "undefined" || theGroup != lastGroup) {
+				ul = document.createElement("ul");
+				jQuery(ul).addClass("timeline");
+				container.appendChild(ul);
+				createTiddlyElement(ul,"li",null,"listTitle",theGroup);
+				lastGroup = theGroup;
+			}
+			var item = createTiddlyElement(ul,"li",null,"listLink");
+			wikify(itemTemplate,item,null,tiddler);
+		}
+	},
+	groupTemplate: "<<view %0 date '%1'>>", 
+	itemTemplate: "<<view title link>>"
+});
+
+config.macros.tiddler.handler = function(place,macroName,params,wikifier,paramString,tiddler)
+{
+	var allowEval = true;
+	var stack = config.macros.tiddler.tiddlerStack;
+	if(stack.length > 0 && config.evaluateMacroParameters == "system") {
+		// included tiddler and "system" evaluation required, so check tiddler tagged appropriately
+		var title = stack[stack.length-1];
+		var pos = title.indexOf(config.textPrimitives.sectionSeparator);
+		if(pos != -1) {
+			title = title.substr(0,pos); // get the base tiddler title
+		}
+		var t = store.getTiddler(title);
+		if(!t || t.tags.indexOf("systemAllowEval") == -1) {
+			allowEval = false;
+		}
+	}
+	params = paramString.parseParams("name",null,allowEval,false,true);
+	var names = params[0]["name"];
+	var tiddlerName = names[0];
+	var className = names[1] || null;
+	var args = params[0]["with"];
+	var wrapper = createTiddlyElement(place,"span",null,className,null,{
+		refresh: "content", tiddler: tiddlerName
+	});
+	if(args!==undefined)
+		wrapper.setAttribute("args","[["+args.join("]] [[")+"]]");
+	this.transclude(wrapper,tiddlerName,args);
+};
+
+config.macros.tiddler.transclude = function(wrapper,tiddlerName,args)
+{
+	var text = store.getTiddlerText(tiddlerName);
+	if(!text)
+		return;
+	var stack = config.macros.tiddler.tiddlerStack;
+	if(stack.indexOf(tiddlerName) !== -1)
+		return;
+	stack.push(tiddlerName);
+	try {
+		if(typeof args == "string")
+			args = args.readBracketedList();
+		var n = args ? Math.min(args.length,9) : 0;
+		var i;
+		for(i=0; i<n; i++) {
+			var placeholderRE = new RegExp("\\$" + (i + 1),"mg");
+			text = text.replace(placeholderRE,args[i]);
+		}
+		config.macros.tiddler.renderText(wrapper,text,tiddlerName);
+	} finally {
+		stack.pop();
+	}
+};
+
+config.macros.tiddler.renderText = function(place,text,tiddlerName)
+{
+	wikify(text,place,null,store.getTiddler(tiddlerName));
+};
+
+config.macros.tiddler.tiddlerStack = [];
+
+//# params[0] - tag
+//# params[1] - title (optional)
+//# params[2] - tooltip (optional)
+//# params[3] - sortby (optional)
+config.macros.tag.handler = function(place,macroName,params)
+{
+	var btn = createTagButton(place,params[0],null,params[1],params[2]);
+	if(params[3]) {
+		btn.setAttribute('sortby',params[3]);
+	}
+};
+
+config.macros.tags.handler = function(place,macroName,params,wikifier,paramString,tiddler)
+{
+	params = paramString.parseParams("anon",null,true,false,false);
+	var ul = createTiddlyElement(place,"ul");
+	var title = getParam(params,"anon","");
+	if(title && store.tiddlerExists(title))
+		tiddler = store.getTiddler(title);
+	var sep = getParam(params,"sep"," ");
+	var lingo = config.views.wikified.tag;
+	var label = null;
+	var t;
+	for(t=0; t<tiddler.tags.length; t++) {
+		var tag = store.getTiddler(tiddler.tags[t]);
+		if(!tag || !tag.tags.contains("excludeLists")) {
+			if(!label)
+				label = createTiddlyElement(ul,"li",null,"listTitle",lingo.labelTags.format([tiddler.title]));
+			createTagButton(createTiddlyElement(ul,"li"),tiddler.tags[t],tiddler.title);
+			if(t<tiddler.tags.length-1)
+				createTiddlyText(ul,sep);
+		}
+	}
+	if(!label)
+		createTiddlyElement(ul,"li",null,"listTitle",lingo.labelNoTags.format([tiddler.title]));
+};
+
+config.macros.tagging.handler = function(place,macroName,params,wikifier,paramString,tiddler)
+{
+	params = paramString.parseParams("anon",null,true,false,false);
+	var ul = createTiddlyElement(place,"ul");
+	var title = getParam(params,"anon","");
+	if(title == "" && tiddler instanceof Tiddler)
+		title = tiddler.title;
+	var sep = getParam(params,"sep"," ");
+	ul.setAttribute("title",this.tooltip.format([title]));
+	var sortby = getParam(params,"sortBy",false);
+	var tagged = store.getTaggedTiddlers(title,sortby);
+	var prompt = tagged.length == 0 ? this.labelNotTag : this.label;
+	createTiddlyElement(ul,"li",null,"listTitle",prompt.format([title,tagged.length]));
+	var t;
+	for(t=0; t<tagged.length; t++) {
+		createTiddlyLink(createTiddlyElement(ul,"li"),tagged[t].title,true);
+		if(t<tagged.length-1)
+			createTiddlyText(ul,sep);
+	}
+};
+
+config.macros.closeAll.handler = function(place)
+{
+	createTiddlyButton(place,this.label,this.prompt,this.onClick);
+};
+
+config.macros.closeAll.onClick = function(e)
+{
+	story.closeAllTiddlers();
+	return false;
+};
+
+config.macros.permaview.handler = function(place)
+{
+	createTiddlyButton(place,this.label,this.prompt,this.onClick);
+};
+
+config.macros.permaview.onClick = function(e)
+{
+	story.permaView();
+	return false;
+};
+
+config.macros.saveChanges.handler = function(place,macroName,params)
+{
+	if(!readOnly)
+		createTiddlyButton(place,params[0] || this.label,params[1] || this.prompt,this.onClick,null,null,this.accessKey);
+};
+
+config.macros.saveChanges.onClick = function(e)
+{
+	saveChanges();
+	return false;
+};
+
+config.macros.slider.onClickSlider = function(ev)
+{
+	var n = this.nextSibling;
+	var cookie = n.getAttribute("cookie");
+	var isOpen = n.style.display != "none";
+	if(config.options.chkAnimate && anim && typeof Slider == "function")
+		anim.startAnimating(new Slider(n,!isOpen,null,"none"));
+	else
+		n.style.display = isOpen ? "none" : "block";
+	config.options[cookie] = !isOpen;
+	saveOption(cookie);
+	return false;
+};
+
+config.macros.slider.createSlider = function(place,cookie,title,tooltip)
+{
+	var c = cookie || "";
+	createTiddlyButton(place,title,tooltip,this.onClickSlider);
+	var panel = createTiddlyElement(null,"div",null,"sliderPanel");
+	panel.setAttribute("cookie",c);
+	panel.style.display = config.options[c] ? "block" : "none";
+	place.appendChild(panel);
+	return panel;
+};
+
+config.macros.slider.handler = function(place,macroName,params)
+{
+	var panel = this.createSlider(place,params[0],params[2],params[3]);
+	var text = store.getTiddlerText(params[1]);
+	panel.setAttribute("refresh","content");
+	panel.setAttribute("tiddler",params[1]);
+	if(text)
+		wikify(text,panel,null,store.getTiddler(params[1]));
+};
+
+// <<gradient [[tiddler name]] vert|horiz rgb rgb rgb rgb... >>
+config.macros.gradient.handler = function(place,macroName,params,wikifier,paramString,tiddler)
+{
+	var panel = wikifier ? createTiddlyElement(place,"div",null,"gradient") : place;
+	panel.style.position = "relative";
+	panel.style.overflow = "hidden";
+	panel.style.zIndex = "0";
+	if(wikifier) {
+		var styles = config.formatterHelpers.inlineCssHelper(wikifier);
+		config.formatterHelpers.applyCssHelper(panel,styles);
+	}
+	params = paramString.parseParams("color");
+	var locolors = [], hicolors = [];
+	var t;
+	for(t=2; t<params.length; t++) {
+		var c = params[t].value;
+		if(params[t].name == "snap") {
+			hicolors[hicolors.length-1] = c;
+		} else {
+			locolors.push(c);
+			hicolors.push(c);
+		}
+	}
+	drawGradient(panel,params[1].value != "vert",locolors,hicolors);
+	if(wikifier)
+		wikifier.subWikify(panel,">>");
+	if(document.all) {
+		panel.style.height = "100%";
+		panel.style.width = "100%";
+	}
+};
+
+config.macros.message.handler = function(place,macroName,params)
+{
+	if(params[0]) {
+		var names = params[0].split(".");
+		var lookupMessage = function(root,nameIndex) {
+				if(root[names[nameIndex]]) {
+					if(nameIndex < names.length-1)
+						return (lookupMessage(root[names[nameIndex]],nameIndex+1));
+					else
+						return root[names[nameIndex]];
+				} else
+					return null;
+			};
+		var m = lookupMessage(config,0);
+		if(m == null)
+			m = lookupMessage(window,0);
+		createTiddlyText(place,m.toString().format(params.splice(1)));
+	}
+};
+
+
+config.macros.view.depth = 0;
+config.macros.view.values = [];
+config.macros.view.views = {
+	text: function(value,place,params,wikifier,paramString,tiddler) {
+		highlightify(value,place,highlightHack,tiddler);
+	},
+	link: function(value,place,params,wikifier,paramString,tiddler) {
+		createTiddlyLink(place,value,true);
+	},
+	wikified: function(value,place,params,wikifier,paramString,tiddler) {
+		if(config.macros.view.depth>50)
+			return;
+		if(config.macros.view.depth>0) {
+			if (value==config.macros.view.values[config.macros.view.depth-1]) {
+				return;
+			}
+		}
+		config.macros.view.values[config.macros.view.depth] = value;
+		config.macros.view.depth++;
+		if(params[2])
+			value=params[2].unescapeLineBreaks().format([value]);
+		wikify(value,place,highlightHack,tiddler);
+		config.macros.view.depth--;
+		config.macros.view.values[config.macros.view.depth] = null;
+	},
+	date: function(value,place,params,wikifier,paramString,tiddler) {
+		value = Date.convertFromYYYYMMDDHHMM(value);
+		createTiddlyText(place,value.formatString(params[2] || config.views.wikified.dateFormat));
+	}
+};
+
+config.macros.view.handler = function(place,macroName,params,wikifier,paramString,tiddler)
+{
+	if((tiddler instanceof Tiddler) && params[0]) {
+		var value = store.getValue(tiddler,params[0]);
+		if(value) {
+			var type = params[1] || config.macros.view.defaultView;
+			var handler = config.macros.view.views[type];
+			if(handler)
+				handler(value,place,params,wikifier,paramString,tiddler);
+		}
+	}
+};
+
+config.macros.edit.handler = function(place,macroName,params,wikifier,paramString,tiddler)
+{
+	var field = params[0];
+	var rows = params[1] || 0;
+	var defVal = params[2] || '';
+	if((tiddler instanceof Tiddler) && field) {
+		story.setDirty(tiddler.title,true);
+		var e,v;
+		if(field != "text" && !rows) {
+			e = createTiddlyElement(null,"input",null,null,null,{
+				type: "text", edit: field, size: "40", autocomplete: "off"
+			});
+			e.value = store.getValue(tiddler,field) || defVal;
+			place.appendChild(e);
+		} else {
+			var wrapper1 = createTiddlyElement(null,"fieldset",null,"fieldsetFix");
+			var wrapper2 = createTiddlyElement(wrapper1,"div");
+			e = createTiddlyElement(wrapper2,"textarea");
+			e.value = v = store.getValue(tiddler,field) || defVal;
+			rows = rows || 10;
+			var lines = v.match(/\n/mg);
+			var maxLines = Math.max(parseInt(config.options.txtMaxEditRows,10),5);
+			if(lines != null && lines.length > rows)
+				rows = lines.length + 5;
+			rows = Math.min(rows,maxLines);
+			e.setAttribute("rows",rows);
+			e.setAttribute("edit",field);
+			place.appendChild(wrapper1);
+		}
+		if(tiddler.isReadOnly()) {
+			e.setAttribute("readOnly","readOnly");
+			jQuery(e).addClass("readOnly");
+		}
+		return e;
+	}
+};
+
+config.macros.tagChooser.onClick = function(ev)
+{
+	var e = ev || window.event;
+	var lingo = config.views.editor.tagChooser;
+	var popup = Popup.create(this);
+	var tags = store.getTags(this.getAttribute("tags"));
+	if(tags.length == 0)
+		jQuery("<li/>").text(lingo.popupNone).appendTo(popup);
+	var t;
+	for(t=0; t<tags.length; t++) {
+		var tag = createTiddlyButton(createTiddlyElement(popup,"li"),tags[t][0],lingo.tagTooltip.format([tags[t][0]]),config.macros.tagChooser.onTagClick);
+		tag.setAttribute("tag",tags[t][0]);
+		tag.setAttribute("tiddler",this.getAttribute("tiddler"));
+	}
+	Popup.show();
+	e.cancelBubble = true;
+	if(e.stopPropagation) e.stopPropagation();
+	return false;
+};
+
+config.macros.tagChooser.onTagClick = function(ev)
+{
+	var e = ev || window.event;
+	if(e.metaKey || e.ctrlKey) stopEvent(e); //# keep popup open on CTRL-click
+	var tag = this.getAttribute("tag");
+	var title = this.getAttribute("tiddler");
+	if(!readOnly)
+		story.setTiddlerTag(title,tag,0);
+	return false;
+};
+
+config.macros.tagChooser.handler = function(place,macroName,params,wikifier,paramString,tiddler)
+{
+	if(tiddler instanceof Tiddler) {
+		var lingo = config.views.editor.tagChooser;
+		var btn = createTiddlyButton(place,lingo.text,lingo.tooltip,this.onClick);
+		btn.setAttribute("tiddler",tiddler.title);
+		btn.setAttribute("tags",params[0]);
+	}
+};
+
+config.macros.refreshDisplay.handler = function(place)
+{
+	createTiddlyButton(place,this.label,this.prompt,this.onClick);
+};
+
+config.macros.refreshDisplay.onClick = function(e)
+{
+	refreshAll();
+	return false;
+};
+
+config.macros.annotations.handler = function(place,macroName,params,wikifier,paramString,tiddler)
+{
+	var title = tiddler ? tiddler.title : null;
+	var a = title ? config.annotations[title] : null;
+	if(!tiddler || !title || !a)
+		return;
+	var text = a.format([title]);
+	wikify(text,createTiddlyElement(place,"div",null,"annotation"),null,tiddler);
+};

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Manager.js

@@ -0,0 +1,99 @@
+//--
+//-- Manager UI for groups of tiddlers
+//--
+
+config.macros.plugins.handler = function(place,macroName,params,wikifier,paramString)
+{
+	var wizard = new Wizard();
+	wizard.createWizard(place,this.wizardTitle);
+	wizard.addStep(this.step1Title,this.step1Html);
+	var markList = wizard.getElement("markList");
+	var listWrapper = document.createElement("div");
+	markList.parentNode.insertBefore(listWrapper,markList);
+	listWrapper.setAttribute("refresh","macro");
+	listWrapper.setAttribute("macroName","plugins");
+	listWrapper.setAttribute("params",paramString);
+	this.refresh(listWrapper,paramString);
+};
+
+config.macros.plugins.refresh = function(listWrapper,params)
+{
+	var me = config.macros.plugins;
+	var wizard = new Wizard(listWrapper);
+	var selectedRows = [];
+	ListView.forEachSelector(listWrapper,function(e,rowName) {
+			if(e.checked)
+				selectedRows.push(e.getAttribute("rowName"));
+		});
+	jQuery(listWrapper).empty();
+	params = params.parseParams("anon");
+	var plugins = installedPlugins.slice(0);
+	var t,tiddler,p;
+	var configTiddlers = store.getTaggedTiddlers("systemConfig");
+	for(t=0; t<configTiddlers.length; t++) {
+		tiddler = configTiddlers[t];
+		if(plugins.findByField("title",tiddler.title) == null) {
+			p = getPluginInfo(tiddler);
+			p.executed = false;
+			p.log.splice(0,0,this.skippedText);
+			plugins.push(p);
+		}
+	}
+	for(t=0; t<plugins.length; t++) {
+		p = plugins[t];
+		p.size = p.tiddler.text ? p.tiddler.text.length : 0;
+		p.forced = p.tiddler.isTagged("systemConfigForce");
+		p.disabled = p.tiddler.isTagged("systemConfigDisable");
+		p.Selected = selectedRows.indexOf(plugins[t].title) != -1;
+	}
+	if(plugins.length == 0) {
+		createTiddlyElement(listWrapper,"em",null,null,this.noPluginText);
+		wizard.setButtons([]);
+	} else {
+		var template = readOnly ? this.listViewTemplateReadOnly : this.listViewTemplate;
+		var listView = ListView.create(listWrapper,plugins,template,this.onSelectCommand);
+		wizard.setValue("listView",listView);
+		if(!readOnly) {
+			wizard.setButtons([
+				{caption: me.removeLabel, tooltip: me.removePrompt, onClick: me.doRemoveTag},
+				{caption: me.deleteLabel, tooltip: me.deletePrompt, onClick: me.doDelete}
+			]);
+		}
+	}
+};
+
+config.macros.plugins.doRemoveTag = function(e)
+{
+	var wizard = new Wizard(this);
+	var listView = wizard.getValue("listView");
+	var rowNames = ListView.getSelectedRows(listView);
+	if(rowNames.length == 0) {
+		alert(config.messages.nothingSelected);
+	} else {
+		var t;
+		for(t=0; t<rowNames.length; t++) {
+			store.setTiddlerTag(rowNames[t],false,"systemConfig");
+		}
+		autoSaveChanges();
+	}
+};
+
+config.macros.plugins.doDelete = function(e)
+{
+	var wizard = new Wizard(this);
+	var listView = wizard.getValue("listView");
+	var rowNames = ListView.getSelectedRows(listView);
+	if(rowNames.length == 0) {
+		alert(config.messages.nothingSelected);
+	} else {
+		if(confirm(config.macros.plugins.confirmDeleteText.format([rowNames.join(", ")]))) {
+			var t;
+			for(t=0; t<rowNames.length; t++) {
+				store.removeTiddler(rowNames[t]);
+				story.closeTiddler(rowNames[t],true);
+			}
+		}
+		autoSaveChanges();
+	}
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Messages.js

@@ -0,0 +1,44 @@
+//--
+//-- Message area
+//--
+
+function getMessageDiv()
+{
+	var msgArea = document.getElementById("messageArea");
+	if(!msgArea)
+		return null;
+	if(!msgArea.hasChildNodes())
+		createTiddlyButton(createTiddlyElement(msgArea,"div",null,"messageToolbar"),
+			config.messages.messageClose.text,
+			config.messages.messageClose.tooltip,
+			clearMessage);
+	msgArea.style.display = "block";
+	return createTiddlyElement(msgArea,"div");
+}
+
+function displayMessage(text,linkText)
+{
+	var e = getMessageDiv();
+	if(!e) {
+		alert(text);
+		return;
+	}
+	if(linkText) {
+		var link = createTiddlyElement(e,"a",null,null,text);
+		link.href = linkText;
+		link.target = "_blank";
+	} else {
+		e.appendChild(document.createTextNode(text));
+	}
+}
+
+function clearMessage()
+{
+	var msgArea = document.getElementById("messageArea");
+	if(msgArea) {
+		jQuery(msgArea).empty();
+		msgArea.style.display = "none";
+	}
+	return false;
+}
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Morpher.js

@@ -0,0 +1,85 @@
+//--
+//-- Morpher animation
+//--
+
+// Animate a set of properties of an element
+//#   element - the element to be moved (optional
+//#   duration - duration of animation
+//#   properties - an array of objects describing each property that is to be modified:
+//#       format - one of:
+//#         "style" for numeric styles (default)
+//#         "color" for #RRGGBB format colour styles
+//#       style - name of the style being animated. Includes pseudo-styles:
+//#         "-tw-scrollVert" - controls vertical scrolling
+//#         "-tw-scrollHoriz" - controls horizontal scrolling
+//#       start - starting value to animate from
+//#       end - ending value to animation from
+//#       atEnd - final value (taking priority over the end value) (eg, for switching style.display)
+//#       template - template for formatString() for setting the property (eg "%0em", or "#%0")
+//#       callback - function to call when the animation has completed as callback(element,properties);
+function Morpher(element,duration,properties,callback)
+{
+	this.element = element;
+	this.duration = duration;
+	this.properties = properties;
+	this.startTime = new Date();
+	this.endTime = Number(this.startTime) + duration;
+	this.callback = callback;
+	this.tick();
+	return this;
+}
+
+Morpher.prototype.assignStyle = function(element,style,value)
+{
+	switch(style) {
+	case "-tw-vertScroll":
+		window.scrollTo(findScrollX(),value);
+		break;
+	case "-tw-horizScroll":
+		window.scrollTo(value,findScrollY());
+		break;
+	default:
+		element.style[style] = value;
+		break;
+	}
+};
+
+Morpher.prototype.stop = function()
+{
+	var t;
+	for(t=0; t<this.properties.length; t++) {
+		var p = this.properties[t];
+		if(p.atEnd !== undefined) {
+			this.assignStyle(this.element,p.style,p.atEnd);
+		}
+	}
+	if(this.callback)
+		this.callback(this.element,this.properties);
+};
+
+Morpher.prototype.tick = function()
+{
+	var currTime = Number(new Date());
+	var t,progress = Animator.slowInSlowOut(Math.min(1,(currTime-this.startTime)/this.duration));
+	for(t=0; t<this.properties.length; t++) {
+		var p = this.properties[t];
+		if(p.start !== undefined && p.end !== undefined) {
+			var template = p.template || "%0";
+			switch(p.format) {
+			case undefined:
+			case "style":
+				var v = p.start + (p.end-p.start) * progress;
+				this.assignStyle(this.element,p.style,template.format([v]));
+				break;
+			case "color":
+				break;
+			}
+		}
+	}
+	if(currTime >= this.endTime) {
+		this.stop();
+		return false;
+	}
+	return true;
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/NewTiddler.js

@@ -0,0 +1,81 @@
+//--
+//-- NewTiddler and NewJournal macros
+//--
+
+config.macros.newTiddler.createNewTiddlerButton = function(place,title,params,label,prompt,accessKey,newFocus,isJournal)
+{
+	var tags = [];
+	var t;
+	for(t=1; t<params.length; t++) {
+		if((params[t].name == "anon" && t != 1) || (params[t].name == "tag"))
+			tags.push(params[t].value);
+	}
+	label = getParam(params,"label",label);
+	prompt = getParam(params,"prompt",prompt);
+	accessKey = getParam(params,"accessKey",accessKey);
+	newFocus = getParam(params,"focus",newFocus);
+	var customFields = getParam(params,"fields","");
+	if(!customFields && !store.isShadowTiddler(title))
+		customFields = String.encodeHashMap(config.defaultCustomFields);
+	var btn = createTiddlyButton(place,label,prompt,this.onClickNewTiddler,null,null,accessKey);
+	btn.setAttribute("newTitle",title);
+	btn.setAttribute("isJournal",isJournal ? "true" : "false");
+	if(tags.length > 0)
+		btn.setAttribute("params",tags.join("|"));
+	btn.setAttribute("newFocus",newFocus);
+	btn.setAttribute("newTemplate",getParam(params,"template",DEFAULT_EDIT_TEMPLATE));
+	if(customFields !== "")
+		btn.setAttribute("customFields",customFields);
+	var text = getParam(params,"text");
+	if(text !== undefined)
+		btn.setAttribute("newText",text);
+	return btn;
+};
+
+config.macros.newTiddler.onClickNewTiddler = function()
+{
+	var title = this.getAttribute("newTitle");
+	if(this.getAttribute("isJournal") == "true") {
+		title = new Date().formatString(title.trim());
+	}
+	var params = this.getAttribute("params");
+	var tags = params ? params.split("|") : [];
+	var focus = this.getAttribute("newFocus");
+	var template = this.getAttribute("newTemplate");
+	var customFields = this.getAttribute("customFields");
+	if(!customFields && !store.isShadowTiddler(title))
+		customFields = String.encodeHashMap(config.defaultCustomFields);
+	story.displayTiddler(null,title,template,false,null,null);
+	var tiddlerElem = story.getTiddler(title);
+	if(customFields)
+		story.addCustomFields(tiddlerElem,customFields);
+	var text = this.getAttribute("newText");
+	if(typeof text == "string" && story.getTiddlerField(title,"text"))
+		story.getTiddlerField(title,"text").value = text.format([title]);
+	var t;
+	for(t=0;t<tags.length;t++)
+		story.setTiddlerTag(title,tags[t],+1);
+	story.focusTiddler(title,focus);
+	return false;
+};
+
+config.macros.newTiddler.handler = function(place,macroName,params,wikifier,paramString)
+{
+	if(!readOnly) {
+		params = paramString.parseParams("anon",null,true,false,false);
+		var title = params[1] && params[1].name == "anon" ? params[1].value : this.title;
+		title = getParam(params,"title",title);
+		this.createNewTiddlerButton(place,title,params,this.label,this.prompt,this.accessKey,"title",false);
+	}
+};
+
+config.macros.newJournal.handler = function(place,macroName,params,wikifier,paramString)
+{
+	if(!readOnly) {
+		params = paramString.parseParams("anon",null,true,false,false);
+		var title = params[1] && params[1].name == "anon" ? params[1].value : config.macros.timeline.dateFormat;
+		title = getParam(params,"title",title);
+		config.macros.newTiddler.createNewTiddlerButton(place,title,params,this.label,this.prompt,this.accessKey,"text",true);
+	}
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Numbers.js

@@ -0,0 +1,15 @@
+//--
+//-- Augmented methods for the JavaScript Number() object
+//--
+
+// Clamp a number to a range
+Number.prototype.clamp = function(min,max)
+{
+	var c = this;
+	if(c < min)
+		c = min;
+	if(c > max)
+		c = max;
+	return Number(c);
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Options.js

@@ -0,0 +1,312 @@
+//--
+//-- Option handling
+//--
+
+config.optionHandlers = {
+	'txt': {
+		get: function(name) {return encodeCookie(config.options[name].toString());},
+		set: function(name,value) {config.options[name] = decodeCookie(value);}
+	},
+	'chk': {
+		get: function(name) {return config.options[name] ? 'true' : 'false';},
+		set: function(name,value) {config.options[name] = value == 'true';}
+	}
+};
+
+function setOption(name,value)
+{
+	var optType = name.substr(0,3);
+	if(config.optionHandlers[optType] && config.optionHandlers[optType].set)
+		config.optionHandlers[optType].set(name,value);
+}
+
+// Gets the value of an option as a string. Most code should just read from config.options.* directly
+function getOption(name)
+{
+	var optType = name.substr(0,3);
+	return config.optionHandlers[optType] && config.optionHandlers[optType].get ? config.optionHandlers[optType].get(name) : null;
+}
+
+//# Loads config.options from cookies and SystemSettings
+function loadOptions()
+{
+	if(safeMode)
+		return;
+	loadCookies();
+	loadSystemSettings();
+}
+// @Deprecated; retained for backwards compatibility
+var loadOptionsCookie = loadOptions;
+
+function getCookies()
+{
+	var cookieList = document.cookie.split(';');
+	var i,cookies = {};
+	for(i=0; i<cookieList.length; i++) {
+		var p = cookieList[i].indexOf('=');
+		if(p != -1) {
+			var name = cookieList[i].substr(0,p).trim();
+			var value = cookieList[i].substr(p+1).trim();
+			cookies[name] = value;
+		}
+	}
+	return cookies;
+}
+
+function loadCookies()
+{
+	var i,cookies = getCookies();
+	if(cookies['TiddlyWiki']) {
+		cookies = cookies['TiddlyWiki'].decodeHashMap();
+	}
+	for(i in cookies) {
+		if(config.optionsSource[i] != 'setting') {
+			setOption(i,cookies[i]);
+		}
+	}
+}
+
+function loadSystemSettings()
+{
+	var key,settings = store.calcAllSlices('SystemSettings');
+	config.optionsSource = {};
+	for(key in settings) {
+		setOption(key,settings[key]);
+		config.optionsSource[key] = 'setting';
+	}
+}
+
+//# called back from SystemSettings notifier
+function onSystemSettingsChange()
+{
+	if(!startingUp) {
+		loadSystemSettings();
+	}
+}
+
+function saveOption(name)
+{
+	if(safeMode)
+		return;
+	if(name.match(/[()\s]/g, '_')) {
+		alert(config.messages.invalidCookie.format([name]));
+		return;
+	}
+	saveCookie(name);
+	if(config.optionsSource[name] == 'setting') {
+		saveSystemSetting(name,true);
+	}
+}
+// @Deprecated; retained for backwards compatibility
+var saveOptionCookie = saveOption;
+
+function removeCookie(name)
+{
+	document.cookie = name + '=; expires=Thu, 01-Jan-1970 00:00:01 UTC; path=/;';
+}
+
+function saveCookie(name)
+{
+	var key,cookies = {};
+	for(key in config.options) {
+		var value = getOption(key);
+		value = value == null ? 'false' : value;
+		cookies[key] = value;
+	}
+	document.cookie = 'TiddlyWiki=' + String.encodeHashMap(cookies) + '; expires=Fri, 1 Jan 2038 12:00:00 UTC; path=/';
+	cookies = getCookies();
+	var c;
+	for(c in cookies) {
+		var optType = c.substr(0,3);
+		if(config.optionHandlers[optType])
+			removeCookie(c);
+	}
+}
+
+var systemSettingSave;
+function commitSystemSettings(storeWasDirty)
+{
+	if(systemSettingSave) {
+		window.clearTimeout(systemSettingSave);
+	}
+	systemSettingSave = window.setTimeout(function() {
+		var tiddler = store.getTiddler('SystemSettings');
+		if(storeWasDirty == false && story.areAnyDirty() == false) {
+			//# nothing has changed except the options, so we can force a save
+			saveChanges(null,[tiddler]);
+		} else {
+			autoSaveChanges(null,[tiddler]);
+		}
+	}, 1000);
+}
+
+function saveSystemSetting(name,saveFile)
+{
+	var title = 'SystemSettings';
+	var slice = store.getTiddlerSlice(title,name);
+	if(readOnly || slice === getOption(name)) {
+		return; //# don't save if read-only or the option hasn't changed
+	}
+	var slices = store.calcAllSlices(title);
+	var key;
+	for(key in config.optionsSource) {
+		var value = getOption(key) || '';
+		if(slices[key] !== value) {
+			slices[key] = value;
+		}
+	}
+	var text = [];
+	for(key in slices) {
+		text.push('%0: %1'.format([key,slices[key]]));
+	}
+	text = text.sort().join('\n');
+	var storeWasDirty = store.isDirty();
+	var tiddler = store.getTiddler(title);
+	if(tiddler) {
+		tiddler.text = text;
+		tiddler = store.saveTiddler(tiddler);
+	} else {
+		tiddler = store.saveTiddler(title,title,text,'System',new Date(),['excludeLists'],config.defaultCustomFields);
+	}
+	if(saveFile) {
+		commitSystemSettings(storeWasDirty);
+	}
+}
+
+//# Flatten cookies to ANSI character set by substituting html character entities for non-ANSI characters
+function encodeCookie(s)
+{
+	return escape(convertUnicodeToHtmlEntities(s));
+}
+
+//# Decode any html character entities to their unicode equivalent
+function decodeCookie(s)
+{
+	s = unescape(s);
+	var re = /&#[0-9]{1,5};/g;
+	return s.replace(re,function($0) {return String.fromCharCode(eval($0.replace(/[&#;]/g,'')));});
+}
+
+config.macros.option.genericCreate = function(place,type,opt,className,desc)
+{
+	var typeInfo = config.macros.option.types[type];
+	var c = document.createElement(typeInfo.elementType);
+	if(typeInfo.typeValue)
+		c.setAttribute('type',typeInfo.typeValue);
+	c[typeInfo.eventName] = typeInfo.onChange;
+	c.setAttribute('option',opt);
+	c.className = className || typeInfo.className;
+	if(config.optionsDesc[opt])
+		c.setAttribute('title',config.optionsDesc[opt]);
+	place.appendChild(c);
+	if(desc != 'no')
+		createTiddlyText(place,config.optionsDesc[opt] || opt);
+	c[typeInfo.valueField] = config.options[opt];
+	return c;
+};
+
+config.macros.option.genericOnChange = function(e)
+{
+	var opt = this.getAttribute('option');
+	if(opt) {
+		var optType = opt.substr(0,3);
+		var handler = config.macros.option.types[optType];
+		if(handler.elementType && handler.valueField)
+			config.macros.option.propagateOption(opt,handler.valueField,this[handler.valueField],handler.elementType,this);
+	}
+	return true;
+};
+
+config.macros.option.types = {
+	'txt': {
+		elementType: 'input',
+		valueField: 'value',
+		eventName: 'onchange',
+		className: 'txtOptionInput',
+		create: config.macros.option.genericCreate,
+		onChange: config.macros.option.genericOnChange
+	},
+	'chk': {
+		elementType: 'input',
+		valueField: 'checked',
+		eventName: 'onclick',
+		className: 'chkOptionInput',
+		typeValue: 'checkbox',
+		create: config.macros.option.genericCreate,
+		onChange: config.macros.option.genericOnChange
+	}
+};
+
+config.macros.option.propagateOption = function(opt,valueField,value,elementType,elem)
+{
+	config.options[opt] = value;
+	saveOption(opt);
+	var t,nodes = document.getElementsByTagName(elementType);
+	for(t=0; t<nodes.length; t++) {
+		var optNode = nodes[t].getAttribute('option');
+		if(opt == optNode && nodes[t]!=elem)
+			nodes[t][valueField] = value;
+	}
+};
+
+config.macros.option.handler = function(place,macroName,params,wikifier,paramString)
+{
+	params = paramString.parseParams('anon',null,true,false,false);
+	var opt = (params[1] && params[1].name == 'anon') ? params[1].value : getParam(params,'name',null);
+	var className = (params[2] && params[2].name == 'anon') ? params[2].value : getParam(params,'class',null);
+	var desc = getParam(params,'desc','no');
+	var type = opt.substr(0,3);
+	var h = config.macros.option.types[type];
+	if(h && h.create)
+		h.create(place,type,opt,className,desc);
+};
+
+config.macros.options.handler = function(place,macroName,params,wikifier,paramString)
+{
+	params = paramString.parseParams('anon',null,true,false,false);
+	var showUnknown = getParam(params,'showUnknown','no');
+	var wizard = new Wizard();
+	wizard.createWizard(place,this.wizardTitle);
+	wizard.addStep(this.step1Title,this.step1Html);
+	var markList = wizard.getElement('markList');
+	var chkUnknown = wizard.getElement('chkUnknown');
+	chkUnknown.checked = showUnknown == 'yes';
+	chkUnknown.onchange = this.onChangeUnknown;
+	var listWrapper = document.createElement('div');
+	markList.parentNode.insertBefore(listWrapper,markList);
+	wizard.setValue('listWrapper',listWrapper);
+	this.refreshOptions(listWrapper,showUnknown == 'yes');
+};
+
+config.macros.options.refreshOptions = function(listWrapper,showUnknown)
+{
+	var n,opts = [];
+	for(n in config.options) {
+		var opt = {};
+		opt.option = '';
+		opt.name = n;
+		opt.lowlight = !config.optionsDesc[n];
+		opt.description = opt.lowlight ? this.unknownDescription : config.optionsDesc[n];
+		if(!opt.lowlight || showUnknown)
+			opts.push(opt);
+	}
+	opts.sort(function(a,b) {return a.name.substr(3) < b.name.substr(3) ? -1 : (a.name.substr(3) == b.name.substr(3) ? 0 : +1);});
+	ListView.create(listWrapper,opts,this.listViewTemplate);
+	for(n=0; n<opts.length; n++) {
+		var type = opts[n].name.substr(0,3);
+		var h = config.macros.option.types[type];
+		if(h && h.create) {
+			h.create(opts[n].colElements['option'],type,opts[n].name,null,'no');
+		}
+	}
+};
+
+config.macros.options.onChangeUnknown = function(e)
+{
+	var wizard = new Wizard(this);
+	var listWrapper = wizard.getValue('listWrapper');
+	jQuery(listWrapper).empty();
+	config.macros.options.refreshOptions(listWrapper,this.checked);
+	return false;
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Paramifiers.js

@@ -0,0 +1,135 @@
+//--
+//-- Paramifiers
+//--
+
+function getParameters()
+{
+	var p = null;
+	if(window.location.hash) {
+		p = decodeURIComponent(window.location.hash.substr(1));
+		if(config.browser.firefoxDate != null && config.browser.firefoxDate[1] < "20051111")
+			p = convertUTF8ToUnicode(p);
+	}
+	return p;
+}
+
+function invokeParamifier(params,handler)
+{
+	if(!params || params.length == undefined || params.length <= 1)
+		return;
+	var i;
+	for(i=1; i<params.length; i++) {
+		var p = config.paramifiers[params[i].name];
+		if(p && p[handler] instanceof Function)
+			p[handler](params[i].value);
+		else {
+			//# not a paramifier with handler()... check for an 'option' prefix
+			var h = config.optionHandlers[params[i].name.substr(0,3)];
+			if(h && h.set instanceof Function)
+				h.set(params[i].name,params[i].value);
+		}
+	}
+}
+
+config.paramifiers = {};
+
+config.paramifiers.start = {
+	oninit: function(v) {
+		safeMode = v.toLowerCase() == "safe";
+	}
+};
+
+config.paramifiers.open = {
+	onstart: function(v) {
+		if(!readOnly || store.tiddlerExists(v) || store.isShadowTiddler(v))
+			story.displayTiddler("bottom",v,null,false,null);
+	}
+};
+
+config.paramifiers.story = {
+	onstart: function(v) {
+		var list = store.getTiddlerText(v,"").parseParams("open",null,false);
+		invokeParamifier(list,"onstart");
+	}
+};
+
+config.paramifiers.search = {
+	onstart: function(v) {
+		story.search(v,false,false);
+	}
+};
+
+config.paramifiers.searchRegExp = {
+	onstart: function(v) {
+		story.prototype.search(v,false,true);
+	}
+};
+
+config.paramifiers.tag = {
+	onstart: function(v) {
+		story.displayTiddlers(null,store.filterTiddlers("[tag["+v+"]]"),null,false,null);
+	}
+};
+
+config.paramifiers.newTiddler = {
+	onstart: function(v) {
+		var args = v.parseParams("anon", null, null)[0];
+		var title = args.title ? args.title[0] : v;
+		var customFields = args.fields ? args.fields[0] : null;
+		if(!readOnly) {
+			story.displayTiddler(null,title,DEFAULT_EDIT_TEMPLATE,false,null,customFields);
+			story.focusTiddler(title,"text");
+			var i,tags = args.tag || [];
+			for(i=0;i<tags.length;i++) {
+				story.setTiddlerTag(title,tags[i],+1);
+			}
+		}
+	}
+};
+
+config.paramifiers.newJournal = {
+	onstart: function(v) {
+		if(!readOnly) {
+			var now = new Date();
+			var title = now.formatString(v.trim());
+			story.displayTiddler(null,title,DEFAULT_EDIT_TEMPLATE);
+			story.focusTiddler(title,"text");
+		}
+	}
+};
+
+config.paramifiers.readOnly = {
+	onconfig: function(v) {
+		var p = v.toLowerCase();
+		readOnly = p == "yes" ? true : (p == "no" ? false : readOnly);
+	}
+};
+
+config.paramifiers.theme = {
+	onconfig: function(v) {
+		story.switchTheme(v);
+	}
+};
+
+config.paramifiers.upgrade = {
+	onstart: function(v) {
+		upgradeFrom(v);
+	}
+};
+
+config.paramifiers.recent= {
+	onstart: function(v) {
+		var titles=[];
+		var i,tiddlers=store.getTiddlers("modified","excludeLists").reverse();
+		for(i=0; i<v && i<tiddlers.length; i++)
+			titles.push(tiddlers[i].title);
+		story.displayTiddlers(null,titles);
+	}
+};
+
+config.paramifiers.filter = {
+	onstart: function(v) {
+		story.displayTiddlers(null,store.filterTiddlers(v),null,false);
+	}
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Popup.js

@@ -0,0 +1,104 @@
+//--
+//-- Popup menu
+//--
+
+var Popup = {
+	stack: [] // Array of objects with members root: and popup:
+	};
+
+Popup.create = function(root,elem,className)
+{
+	var stackPosition = this.find(root,"popup");
+	Popup.remove(stackPosition+1);
+	var popup = createTiddlyElement(document.body,elem || "ol","popup",className || "popup");
+	popup.stackPosition = stackPosition;
+	Popup.stack.push({root: root, popup: popup});
+	return popup;
+};
+
+Popup.onDocumentClick = function(ev)
+{
+	var e = ev || window.event;
+	if(e.eventPhase == undefined)
+		Popup.remove();
+	else if(e.eventPhase == Event.BUBBLING_PHASE || e.eventPhase == Event.AT_TARGET)
+		Popup.remove();
+	return true;
+};
+
+//# valign : "top" or "bottom" (optional)
+//#   defaults to "bottom" for regular popups, "top" for nested popups
+//# halign : "left" or "right" (optional)
+//#   defaults to "left" for regular popups, "right" for nested popups
+//# offset : {x: number, y: number} (optional)
+//#   defaults to {x:0,y:0}
+Popup.show = function(valign,halign,offset)
+{
+	var curr = Popup.stack[Popup.stack.length-1];
+	this.place(curr.root,curr.popup,valign,halign,offset);
+	jQuery(curr.root).addClass("highlight");
+	if(config.options.chkAnimate && anim && typeof Scroller == "function")
+		anim.startAnimating(new Scroller(curr.popup));
+	else
+		window.scrollTo(0,ensureVisible(curr.popup));
+};
+
+Popup.place = function(root,popup,valign,halign,offset)
+{
+	if(!offset)
+		offset = {x:0,y:0};
+	if(popup.stackPosition >= 0 && !valign && !halign) {
+		offset.x = offset.x + root.offsetWidth;
+	} else {
+		offset.x = (halign == "right") ? offset.x + root.offsetWidth : offset.x;
+		offset.y = (valign == "top") ? offset.y : offset.y + root.offsetHeight;
+	}
+	var rootLeft = findPosX(root);
+	var rootTop = findPosY(root);
+	var popupLeft = rootLeft + offset.x;
+	var popupTop = rootTop + offset.y;
+	var winWidth = findWindowWidth();
+	if(popup.offsetWidth > winWidth*0.75)
+		popup.style.width = winWidth*0.75 + "px";
+	var popupWidth = popup.offsetWidth;
+	var scrollWidth = winWidth - document.body.offsetWidth;
+	if(popupLeft + popupWidth > winWidth - scrollWidth - 1) {
+		if(halign == "right")
+			popupLeft = popupLeft - root.offsetWidth - popupWidth;
+		else
+			popupLeft = winWidth - popupWidth - scrollWidth - 1;
+	}
+	popup.style.left = popupLeft + "px";
+	popup.style.top = popupTop + "px";
+	popup.style.display = "block";
+};
+
+Popup.find = function(e)
+{
+	var t,pos = -1;
+	for(t=this.stack.length-1; t>=0; t--) {
+		if(isDescendant(e,this.stack[t].popup))
+			pos = t;
+	}
+	return pos;
+};
+
+Popup.remove = function(pos)
+{
+	if(!pos) pos = 0;
+	if(Popup.stack.length > pos) {
+		Popup.removeFrom(pos);
+	}
+};
+
+Popup.removeFrom = function(from)
+{
+	var t;
+	for(t=Popup.stack.length-1; t>=from; t--) {
+		var p = Popup.stack[t];
+		jQuery(p.root).removeClass("highlight");
+		jQuery(p.popup).remove();
+	}
+	Popup.stack = Popup.stack.slice(0,from);
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/RGB.js

@@ -0,0 +1,59 @@
+//--
+//-- RGB colour object
+//--
+
+// Construct an RGB colour object from a '#rrggbb', '#rgb' or 'rgb(n,n,n)' string or from separate r,g,b values
+function RGB(r,g,b)
+{
+	this.r = 0;
+	this.g = 0;
+	this.b = 0;
+	if(typeof r == "string") {
+		if(r.substr(0,1) == "#") {
+			if(r.length == 7) {
+				this.r = parseInt(r.substr(1,2),16)/255;
+				this.g = parseInt(r.substr(3,2),16)/255;
+				this.b = parseInt(r.substr(5,2),16)/255;
+			} else {
+				this.r = parseInt(r.substr(1,1),16)/15;
+				this.g = parseInt(r.substr(2,1),16)/15;
+				this.b = parseInt(r.substr(3,1),16)/15;
+			}
+		} else {
+			var rgbPattern = /rgb\s*\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*\)/;
+			var c = r.match(rgbPattern);
+			if(c) {
+				this.r = parseInt(c[1],10)/255;
+				this.g = parseInt(c[2],10)/255;
+				this.b = parseInt(c[3],10)/255;
+			}
+		}
+	} else {
+		this.r = r;
+		this.g = g;
+		this.b = b;
+	}
+	return this;
+}
+
+// Mixes this colour with another in a specified proportion
+// c = other colour to mix
+// f = 0..1 where 0 is this colour and 1 is the new colour
+// Returns an RGB object
+RGB.prototype.mix = function(c,f)
+{
+	return new RGB(this.r + (c.r-this.r) * f,this.g + (c.g-this.g) * f,this.b + (c.b-this.b) * f);
+};
+
+// Return an rgb colour as a #rrggbb format hex string
+RGB.prototype.toString = function()
+{
+	var clamp = function(x,min,max) {
+		return x < min ? min : (x > max ? max : x);
+	};
+	return "#" +
+			("0" + Math.floor(clamp(this.r,0,1) * 255).toString(16)).right(2) +
+			("0" + Math.floor(clamp(this.g,0,1) * 255).toString(16)).right(2) +
+			("0" + Math.floor(clamp(this.b,0,1) * 255).toString(16)).right(2);
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Refresh.js

@@ -0,0 +1,192 @@
+//--
+//-- Refresh mechanism
+//--
+
+//# List of notification functions to be called when certain tiddlers are changed or deleted
+config.notifyTiddlers = [
+	{name: "SystemSettings", notify: onSystemSettingsChange},
+	{name: "StyleSheetLayout", notify: refreshStyles},
+	{name: "StyleSheetColors", notify: refreshStyles},
+	{name: "StyleSheet", notify: refreshStyles},
+	{name: "StyleSheetPrint", notify: refreshStyles},
+	{name: "PageTemplate", notify: refreshPageTemplate},
+	{name: "SiteTitle", notify: refreshPageTitle},
+	{name: "SiteSubtitle", notify: refreshPageTitle},
+	{name: "WindowTitle", notify: refreshPageTitle},
+	{name: "ColorPalette", notify: refreshColorPalette},
+	{name: null, notify: refreshDisplay}
+];
+
+//# refresher functions
+config.refreshers = {
+	link: function(e,changeList)
+		{
+		var title = e.getAttribute("tiddlyLink");
+		refreshTiddlyLink(e,title);
+		return true;
+		},
+
+	tiddler: function(e,changeList)
+		{
+		var title = e.getAttribute("tiddler");
+		var template = e.getAttribute("template");
+		if(changeList && (changeList.indexOf && changeList.indexOf(title) != -1) && !story.isDirty(title))
+			story.refreshTiddler(title,template,true);
+		else
+			refreshElements(e,changeList);
+		return true;
+		},
+
+	content: function(e,changeList)
+		{
+		var title = e.getAttribute("tiddler");
+		var force = e.getAttribute("force");
+		var args = e.getAttribute("args");
+		if(force != null || changeList == null || (changeList.indexOf && changeList.indexOf(title) != -1)) {
+			jQuery(e).empty();
+			config.macros.tiddler.transclude(e,title,args);
+			return true;
+		} else
+			return false;
+		},
+
+	macro: function(e,changeList)
+		{
+		var macro = e.getAttribute("macroName");
+		var params = e.getAttribute("params");
+		if(macro)
+			macro = config.macros[macro];
+		if(macro && macro.refresh)
+			macro.refresh(e,params);
+		return true;
+		}
+};
+
+config.refresherData = {
+	styleSheet: "StyleSheet",
+	defaultStyleSheet: "StyleSheet",
+	pageTemplate: "PageTemplate",
+	defaultPageTemplate: "PageTemplate",
+	colorPalette: "ColorPalette",
+	defaultColorPalette: "ColorPalette"
+};
+
+function refreshElements(root,changeList)
+{
+	var c,nodes = root.childNodes;
+	for(c=0; c<nodes.length; c++) {
+		var e = nodes[c], type = null;
+		if(e.getAttribute && (e.tagName ? e.tagName != "IFRAME" : true))
+			type = e.getAttribute("refresh");
+		var refresher = config.refreshers[type];
+		var refreshed = false;
+		if(refresher != undefined)
+			refreshed = refresher(e,changeList);
+		if(e.hasChildNodes() && !refreshed)
+			refreshElements(e,changeList);
+	}
+}
+
+function applyHtmlMacros(root,tiddler)
+{
+	var e = root.firstChild;
+	while(e) {
+		var nextChild = e.nextSibling;
+		if(e.getAttribute) {
+			var macro = e.getAttribute("macro");
+			if(macro) {
+				e.removeAttribute("macro");
+				var params = "";
+				var p = macro.indexOf(" ");
+				if(p != -1) {
+					params = macro.substr(p+1);
+					macro = macro.substr(0,p);
+				}
+				invokeMacro(e,macro,params,null,tiddler);
+			}
+		}
+		if(e.hasChildNodes())
+			applyHtmlMacros(e,tiddler);
+		e = nextChild;
+	}
+}
+
+function refreshPageTemplate(title)
+{
+	var stash = jQuery("<div/>").appendTo("body").hide()[0];
+	var display = story.getContainer();
+	var nodes,t;
+	if(display) {
+		nodes = display.childNodes;
+		for(t=nodes.length-1; t>=0; t--)
+			stash.appendChild(nodes[t]);
+	}
+	var wrapper = document.getElementById("contentWrapper");
+
+	var isAvailable = function(title) {
+		var s = title ? title.indexOf(config.textPrimitives.sectionSeparator) : -1;
+		if(s!=-1)
+			title = title.substr(0,s);
+		return store.tiddlerExists(title) || store.isShadowTiddler(title);
+	};
+	//# protect against non-existent pageTemplate
+	if(!title || !isAvailable(title))
+		title = config.refresherData.pageTemplate;
+	if(!isAvailable(title))
+		title = config.refresherData.defaultPageTemplate; //# this one is always avaialable
+	wrapper.innerHTML = store.getRecursiveTiddlerText(title,null,10);
+	applyHtmlMacros(wrapper);
+	refreshElements(wrapper);
+	display = story.getContainer();
+	jQuery(display).empty();
+	if(!display)
+		display = createTiddlyElement(wrapper,"div",story.containerId());
+	nodes = stash.childNodes;
+	for(t=nodes.length-1; t>=0; t--)
+		display.appendChild(nodes[t]);
+	jQuery(stash).remove();
+}
+
+function refreshDisplay(hint)
+{
+	if(typeof hint == "string")
+		hint = [hint];
+	var e = document.getElementById("contentWrapper");
+	refreshElements(e,hint);
+	if(backstage.isPanelVisible()) {
+		e = document.getElementById("backstage");
+		refreshElements(e,hint);
+	}
+}
+
+function refreshPageTitle()
+{
+	document.title = getPageTitle();
+}
+
+function getPageTitle()
+{
+	return wikifyPlainText(store.getTiddlerText("WindowTitle",""),null,tiddler);
+}
+
+function refreshStyles(title,doc)
+{
+	setStylesheet(title == null ? "" : store.getRecursiveTiddlerText(title,"",10),title,doc || document);
+}
+
+function refreshColorPalette(title)
+{
+	if(!startingUp)
+		refreshAll();
+}
+
+function refreshAll()
+{
+	refreshPageTemplate();
+	refreshDisplay();
+	refreshStyles("StyleSheetLayout");
+	refreshStyles("StyleSheetColors");
+	refreshStyles(config.refresherData.styleSheet);
+	refreshStyles("StyleSheetPrint");
+}
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Saving.js

@@ -0,0 +1,248 @@
+//--
+//-- Saving
+//--
+
+var saveUsingSafari = false;
+
+var startSaveArea = '<div id="' + 'storeArea">'; // Split up into two so that indexOf() of this source doesn't find it
+var startSaveAreaRE = /<((div)|(DIV)) ((id)|(ID))=["']?storeArea['"]?>/; // Used for IE6
+var endSaveArea = '</d' + 'iv>';
+var endSaveAreaCaps = '</D' + 'IV>';
+
+// If there are unsaved changes, force the user to confirm before exitting
+function confirmExit()
+{
+	hadConfirmExit = true;
+	if((store && store.isDirty && store.isDirty()) || (story && story.areAnyDirty && story.areAnyDirty()))
+		return config.messages.confirmExit;
+}
+
+// Give the user a chance to save changes before exitting
+function checkUnsavedChanges()
+{
+	if(store && store.isDirty && store.isDirty() && window.hadConfirmExit === false) {
+		if(confirm(config.messages.unsavedChangesWarning))
+			saveChanges();
+	}
+}
+
+function updateLanguageAttribute(s)
+{
+	if(config.locale) {
+		var mRE = /(<html(?:.*?)?)(?: xml:lang\="([a-z]+)")?(?: lang\="([a-z]+)")?>/;
+		var m = mRE.exec(s);
+		if(m) {
+			var t = m[1];
+			if(m[2])
+				t += ' xml:lang="' + config.locale + '"';
+			if(m[3])
+				t += ' lang="' + config.locale + '"';
+			t += ">";
+			s = s.substr(0,m.index) + t + s.substr(m.index+m[0].length);
+		}
+	}
+	return s;
+}
+
+function updateMarkupBlock(s,blockName,tiddlerName)
+{
+	return s.replaceChunk(
+			"<!--%0-START-->".format([blockName]),
+			"<!--%0-END-->".format([blockName]),
+			"\n" + convertUnicodeToFileFormat(store.getRecursiveTiddlerText(tiddlerName,"")) + "\n");
+}
+
+function updateOriginal(original,posDiv,localPath)
+{
+	if(!posDiv)
+		posDiv = locateStoreArea(original);
+	if(!posDiv) {
+		alert(config.messages.invalidFileError.format([localPath]));
+		return null;
+	}
+	var revised = original.substr(0,posDiv[0] + startSaveArea.length) + "\n" +
+				convertUnicodeToFileFormat(store.allTiddlersAsHtml()) + "\n" +
+				original.substr(posDiv[1]);
+	var newSiteTitle = convertUnicodeToFileFormat(getPageTitle()).htmlEncode();
+	revised = revised.replaceChunk("<title"+">","</title"+">"," " + newSiteTitle + " ");
+	revised = updateLanguageAttribute(revised);
+	revised = updateMarkupBlock(revised,"PRE-HEAD","MarkupPreHead");
+	revised = updateMarkupBlock(revised,"POST-HEAD","MarkupPostHead");
+	revised = updateMarkupBlock(revised,"PRE-BODY","MarkupPreBody");
+	revised = updateMarkupBlock(revised,"POST-SCRIPT","MarkupPostBody");
+	return revised;
+}
+
+function locateStoreArea(original)
+{
+	// Locate the storeArea divs
+	if(!original)
+		return null;
+	var posOpeningDiv = original.search(startSaveAreaRE);
+	var limitClosingDiv = original.indexOf("<"+"!--POST-STOREAREA--"+">");
+	if(limitClosingDiv == -1)
+		limitClosingDiv = original.indexOf("<"+"!--POST-BODY-START--"+">");
+	var start = limitClosingDiv == -1 ? original.length : limitClosingDiv;
+	var posClosingDiv = original.lastIndexOf(endSaveArea,start);
+	if(posClosingDiv == -1)
+		posClosingDiv = original.lastIndexOf(endSaveAreaCaps,start);
+	return (posOpeningDiv != -1 && posClosingDiv != -1) ? [posOpeningDiv,posClosingDiv] : null;
+}
+
+function autoSaveChanges(onlyIfDirty,tiddlers)
+{
+	if(config.options.chkAutoSave)
+		saveChanges(onlyIfDirty,tiddlers);
+}
+
+function loadOriginal(localPath)
+{
+	return loadFile(localPath);
+}
+
+// Save this tiddlywiki with the pending changes
+function saveChanges(onlyIfDirty,tiddlers)
+{
+	if(onlyIfDirty && !store.isDirty())
+		return;
+	clearMessage();
+	var t0 = new Date();
+	var msg = config.messages;
+	//# Get the URL of the document
+	var originalPath = document.location.toString();
+	//# Check we were loaded from a file URL
+	if(originalPath.substr(0,5) != "file:") {
+		alert(msg.notFileUrlError);
+		if(store.tiddlerExists(msg.saveInstructions))
+			story.displayTiddler(null,msg.saveInstructions);
+		return;
+	}
+	var localPath = getLocalPath(originalPath);
+	//# Load the original file
+	var original = loadOriginal(localPath);
+	if(original == null) {
+		alert(msg.cantSaveError);
+		if(store.tiddlerExists(msg.saveInstructions))
+			story.displayTiddler(null,msg.saveInstructions);
+		return;
+	}
+	//# Locate the storeArea div's
+	var posDiv = locateStoreArea(original);
+	if(!posDiv) {
+		alert(msg.invalidFileError.format([localPath]));
+		return;
+	}
+	saveMain(localPath,original,posDiv);
+	if(config.options.chkSaveBackups)
+		saveBackup(localPath,original);
+	if(config.options.chkSaveEmptyTemplate)
+		saveEmpty(localPath,original,posDiv);
+	if(config.options.chkGenerateAnRssFeed && saveRss instanceof Function)
+		saveRss(localPath);
+	if(config.options.chkDisplayInstrumentation)
+		displayMessage("saveChanges " + (new Date()-t0) + " ms");
+}
+
+function saveMain(localPath,original,posDiv)
+{
+	var save;
+	try {
+		//# Save new file
+		var revised = updateOriginal(original,posDiv,localPath);
+		save = saveFile(localPath,revised);
+	} catch (ex) {
+		showException(ex);
+	}
+	if(save) {
+		displayMessage(config.messages.mainSaved,"file://" + localPath);
+		store.setDirty(false);
+	} else {
+		alert(config.messages.mainFailed);
+	}
+}
+
+function saveBackup(localPath,original)
+{
+	//# Save the backup
+	var backupPath = getBackupPath(localPath);
+	var backup = copyFile(backupPath,localPath);
+	//# Browser does not support copy, so use save instead
+	if(!backup)
+		backup = saveFile(backupPath,original);
+	if(backup)
+		displayMessage(config.messages.backupSaved,"file://" + backupPath);
+	else
+		alert(config.messages.backupFailed);
+}
+
+function saveEmpty(localPath,original,posDiv)
+{
+	//# Save empty template
+	var emptyPath,p;
+	if((p = localPath.lastIndexOf("/")) != -1)
+		emptyPath = localPath.substr(0,p) + "/";
+	else if((p = localPath.lastIndexOf("\\")) != -1)
+		emptyPath = localPath.substr(0,p) + "\\";
+	else
+		emptyPath = localPath + ".";
+	emptyPath += "empty.html";
+	var empty = original.substr(0,posDiv[0] + startSaveArea.length) + original.substr(posDiv[1]);
+	var emptySave = saveFile(emptyPath,empty);
+	if(emptySave)
+		displayMessage(config.messages.emptySaved,"file://" + emptyPath);
+	else
+		alert(config.messages.emptyFailed);
+}
+
+function getLocalPath(origPath)
+{
+	var originalPath = convertUriToUTF8(origPath,config.options.txtFileSystemCharSet);
+	// Remove any location or query part of the URL
+	var argPos = originalPath.indexOf("?");
+	if(argPos != -1)
+		originalPath = originalPath.substr(0,argPos);
+	var hashPos = originalPath.indexOf("#");
+	if(hashPos != -1)
+		originalPath = originalPath.substr(0,hashPos);
+	// Convert file://localhost/ to file:///
+	if(originalPath.indexOf("file://localhost/") == 0)
+		originalPath = "file://" + originalPath.substr(16);
+	// Convert to a native file format
+	//# "file:///x:/path/path/path..." - pc local file --> "x:\path\path\path..."
+	//# "file://///server/share/path/path/path..." - FireFox pc network file --> "\\server\share\path\path\path..."
+	//# "file:///path/path/path..." - mac/unix local file --> "/path/path/path..."
+	//# "file://server/share/path/path/path..." - pc network file --> "\\server\share\path\path\path..."
+	var localPath;
+	if(originalPath.charAt(9) == ":") // pc local file
+		localPath = unescape(originalPath.substr(8)).replace(new RegExp("/","g"),"\\");
+	else if(originalPath.indexOf("file://///") == 0) // FireFox pc network file
+		localPath = "\\\\" + unescape(originalPath.substr(10)).replace(new RegExp("/","g"),"\\");
+	else if(originalPath.indexOf("file:///") == 0) // mac/unix local file
+		localPath = unescape(originalPath.substr(7));
+	else if(originalPath.indexOf("file:/") == 0) // mac/unix local file
+		localPath = unescape(originalPath.substr(5));
+	else // pc network file
+		localPath = "\\\\" + unescape(originalPath.substr(7)).replace(new RegExp("/","g"),"\\");
+	return localPath;
+}
+
+function getBackupPath(localPath,title,extension)
+{
+	var slash = "\\";
+	var dirPathPos = localPath.lastIndexOf("\\");
+	if(dirPathPos == -1) {
+		dirPathPos = localPath.lastIndexOf("/");
+		slash = "/";
+	}
+	var backupFolder = config.options.txtBackupFolder;
+	if(!backupFolder || backupFolder == "")
+		backupFolder = ".";
+	var backupPath = localPath.substr(0,dirPathPos) + slash + backupFolder + localPath.substr(dirPathPos);
+	backupPath = backupPath.substr(0,backupPath.lastIndexOf(".")) + ".";
+	//# replace illegal filename characters(// \/:*?"<>|) and space with underscore
+	if(title)
+		backupPath += title.replace(/[\\\/\*\?\":<> ]/g,"_") + ".";
+	backupPath += (new Date()).convertToYYYYMMDDHHMMSSMMM() + "." + (extension || "html");
+	return backupPath;
+}
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/SavingRSS.js

@@ -0,0 +1,57 @@
+//--
+//-- RSS Saving
+//--
+
+function saveRss(localPath)
+{
+	var rssPath = localPath.substr(0,localPath.lastIndexOf(".")) + ".xml";
+	if(saveFile(rssPath,convertUnicodeToFileFormat(generateRss())))
+		displayMessage(config.messages.rssSaved,"file://" + rssPath);
+	else
+		alert(config.messages.rssFailed);
+}
+
+tiddlerToRssItem = function(tiddler,uri)
+{
+	var s = "<title" + ">" + tiddler.title.htmlEncode() + "</title" + ">\n";
+	s += "<description>" + wikifyStatic(tiddler.text,null,tiddler).htmlEncode() + "</description>\n";
+	var i;
+	for(i=0; i<tiddler.tags.length; i++)
+		s += "<category>" + tiddler.tags[i] + "</category>\n";
+	s += "<link>" + uri + "#" + encodeURIComponent(String.encodeTiddlyLink(tiddler.title)) + "</link>\n";
+	s +="<pubDate>" + tiddler.modified.toGMTString() + "</pubDate>\n";
+	return s;
+};
+
+function generateRss()
+{
+	var s = [];
+	var d = new Date();
+	var u = store.getTiddlerText("SiteUrl");
+	// Assemble the header
+	s.push("<" + "?xml version=\"1.0\"?" + ">");
+	s.push("<rss version=\"2.0\">");
+	s.push("<channel>");
+	s.push("<title" + ">" + wikifyPlainText(store.getTiddlerText("SiteTitle",""),null,tiddler).htmlEncode() + "</title" + ">");
+	if(u)
+		s.push("<link>" + u.htmlEncode() + "</link>");
+	s.push("<description>" + wikifyPlainText(store.getTiddlerText("SiteSubtitle",""),null,tiddler).htmlEncode() + "</description>");
+	s.push("<language>" + config.locale + "</language>");
+	s.push("<copyright>Copyright " + d.getFullYear() + " " + config.options.txtUserName.htmlEncode() + "</copyright>");
+	s.push("<pubDate>" + d.toGMTString() + "</pubDate>");
+	s.push("<lastBuildDate>" + d.toGMTString() + "</lastBuildDate>");
+	s.push("<docs>http://blogs.law.harvard.edu/tech/rss</docs>");
+	s.push("<generator>TiddlyWiki " + formatVersion() + "</generator>");
+	// The body
+	var tiddlers = store.getTiddlers("modified","excludeLists");
+	var i,n = config.numRssItems > tiddlers.length ? 0 : tiddlers.length-config.numRssItems;
+	for(i=tiddlers.length-1; i>=n; i--) {
+		s.push("<item>\n" + tiddlerToRssItem(tiddlers[i],u) + "\n</item>");
+	}
+	// And footer
+	s.push("</channel>");
+	s.push("</rss>");
+	// Save it all
+	return s.join("\n");
+}
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Scroller.js

@@ -0,0 +1,10 @@
+//--
+//-- Scroller animation
+//--
+
+function Scroller(targetElement)
+{
+	var p = [{style: '-tw-vertScroll', start: findScrollY(), end: ensureVisible(targetElement)}];
+	return new Morpher(targetElement,config.animDuration,p);
+}
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Search.js

@@ -0,0 +1,81 @@
+//--
+//-- Search macro
+//--
+
+config.macros.search.handler = function(place,macroName,params,wikifier,paramString,tiddler)
+{
+	params = paramString.parseParams("anon",null,false,false,false);
+	createTiddlyButton(place,this.label,this.prompt,this.onClick,"searchButton");
+	var txt = createTiddlyElement(null,"input",null,"txtOptionInput searchField");
+	txt.value = getParam(params,"anon","");
+	if(config.browser.isSafari) {
+		txt.setAttribute("type","search");
+		txt.setAttribute("results","5");
+	} else {
+		txt.setAttribute("type","text");
+	}
+	place.appendChild(txt);
+	txt.onkeyup = this.onKeyPress;
+	txt.onfocus = this.onFocus;
+	txt.setAttribute("size",this.sizeTextbox);
+	txt.setAttribute("accessKey",getParam(params,"accesskey",this.accessKey));
+	txt.setAttribute("autocomplete","off");
+	txt.setAttribute("lastSearchText","");
+	txt.setAttribute("placeholder",getParam(params,"placeholder",this.placeholder));
+};
+
+// Global because there's only ever one outstanding incremental search timer
+config.macros.search.timeout = null;
+
+config.macros.search.doSearch = function(txt)
+{
+	if(txt.value.length > 0) {
+		story.search(txt.value,config.options.chkCaseSensitiveSearch,config.options.chkRegExpSearch);
+		txt.setAttribute("lastSearchText",txt.value);
+	}
+};
+
+config.macros.search.onClick = function(e)
+{
+	config.macros.search.doSearch(this.nextSibling);
+	return false;
+};
+
+config.macros.search.onKeyPress = function(ev)
+{
+	var me = config.macros.search;
+	var e = ev || window.event;
+	switch(e.keyCode) {
+		case 9: // Tab
+			return;
+		case 13: // Ctrl-Enter
+		case 10: // Ctrl-Enter on IE PC
+			me.doSearch(this);
+			break;
+		case 27: // Escape
+			this.value = "";
+			clearMessage();
+			break;
+	}
+	if(config.options.chkIncrementalSearch) {
+		if(this.value.length > 2) {
+			if(this.value != this.getAttribute("lastSearchText")) {
+				if(me.timeout) {
+					clearTimeout(me.timeout);
+				}
+				var txt = this;
+				me.timeout = setTimeout(function() {me.doSearch(txt);},500);
+			}
+		} else {
+			if(me.timeout) {
+				clearTimeout(me.timeout);
+			}
+		}
+	}
+};
+
+config.macros.search.onFocus = function(e)
+{
+	this.select();
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Slider.js

@@ -0,0 +1,35 @@
+//--
+//-- Slider animation
+//--
+
+// deleteMode - "none", "all" [delete target element and it's children], [only] "children" [but not the target element]
+function Slider(element,opening,unused,deleteMode)
+{
+	element.style.overflow = 'hidden';
+	if(opening)
+		element.style.height = '0px'; // Resolves a Firefox flashing bug
+	element.style.display = 'block';
+	var height = element.scrollHeight;
+	var p = [];
+	var c = null;
+	if(opening) {
+		p.push({style: 'height', start: 0, end: height, template: '%0px', atEnd: 'auto'});
+		p.push({style: 'opacity', start: 0, end: 1, template: '%0'});
+		p.push({style: 'filter', start: 0, end: 100, template: 'alpha(opacity:%0)'});
+	} else {
+		p.push({style: 'height', start: height, end: 0, template: '%0px'});
+		p.push({style: 'display', atEnd: 'none'});
+		p.push({style: 'opacity', start: 1, end: 0, template: '%0'});
+		p.push({style: 'filter', start: 100, end: 0, template: 'alpha(opacity:%0)'});
+		switch(deleteMode) {
+		case "all":
+			c = function(element,properties) {jQuery(element).remove();};
+			break;
+		case "children":
+			c = function(element,properties) {jQuery(element).empty();};
+			break;
+		}
+	}
+	return new Morpher(element,config.animDuration,p,c);
+}
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Sparkline.js

@@ -0,0 +1,56 @@
+//--
+//-- Sparklines
+//--
+
+config.macros.sparkline = {};
+
+config.shadowTiddlers.StyleSheetSparklines = "/*{{{*/\n" +
+	".sparkline {\n" +
+	"\tline-height: 1em;\n" +
+	"\tborder: 0;\n" +
+	"\tbackground: [[ColorPalette::PrimaryPale]];\n" +
+	"}\n\n" +
+	".sparktick {\n" +
+	"\toutline: 0;\n" +
+	"\tbackground: [[ColorPalette::PrimaryDark]];\n" +
+	"}\n" +
+	"/*}}}*/";
+store.addNotification("StyleSheetSparklines", refreshStyles);
+
+config.macros.sparkline.handler = function(place,macroName,params)
+{
+	var data = [];
+	var min = 0;
+	var max = 0;
+	var v;
+	for(var t=0; t<params.length; t++) {
+		v = parseInt(params[t],10);
+		if(v < min)
+			min = v;
+		if(v > max)
+			max = v;
+		data.push(v);
+	}
+	if(data.length < 1)
+		return;
+	var box = createTiddlyElement(place,"span",null,"sparkline",String.fromCharCode(160));
+	box.title = data.join(",");
+	var w = box.offsetWidth;
+	var h = box.offsetHeight;
+	box.style.paddingRight = (data.length * 2 - w) + "px";
+	box.style.position = "relative";
+	for(var d=0; d<data.length; d++) {
+		var tick = document.createElement("img");
+		tick.border = 0;
+		tick.className = "sparktick";
+		tick.style.position = "absolute";
+		tick.src = "data:image/gif,GIF89a%01%00%01%00%91%FF%00%FF%FF%FF%00%00%00%C0%C0%C0%00%00%00!%F9%04%01%00%00%02%00%2C%00%00%00%00%01%00%01%00%40%02%02T%01%00%3B";
+		tick.style.left = d*2 + "px";
+		tick.style.width = "2px";
+		v = Math.floor(((data[d] - min)/(max-min)) * h);
+		tick.style.top = (h-v) + "px";
+		tick.style.height = v + "px";
+		box.appendChild(tick);
+	}
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Story.js

@@ -0,0 +1,712 @@
+//--
+//-- Story functions
+//--
+
+//# A story is a HTML div containing a sequence of tiddlers that can be manipulated
+//# container - id of containing element
+//# idPrefix - string prefix prepended to title to make ids for tiddlers in this story
+function Story(containerId,idPrefix)
+{
+	this.container = containerId;
+	this.idPrefix = idPrefix;
+	this.highlightRegExp = null;
+	//# generate tiddler ID
+	this.tiddlerId = function(title) {
+		//# replace spaces in titles to ensure valid element IDs
+		title = title.replace(/_/g, "__").replace(/ /g, "_");
+		var id = this.idPrefix + title;
+		return id==this.container ? this.idPrefix + "_" + title : id;
+	};
+	this.containerId = function() {
+		return this.container;
+	};
+}
+
+//# retrieve tiddler element
+Story.prototype.getTiddler = function(title)
+{
+	return document.getElementById(this.tiddlerId(title));
+};
+
+Story.prototype.getContainer = function()
+{
+	return document.getElementById(this.containerId());
+};
+
+//# Iterate through all the tiddlers currently opened in a story
+//# fn - callback function to be called for each tiddler. Arguments are:
+//#      tiddlerTitle - title of the tiddler
+//#      element - reference to tiddler display element
+Story.prototype.forEachTiddler = function(fn)
+{
+	var place = this.getContainer();
+	if(!place)
+		return;
+	var e = place.firstChild;
+	while(e) {
+		var n = e.nextSibling;
+		var title = e.getAttribute("tiddler");
+		fn.call(this,title,e);
+		e = n;
+	}
+};
+
+Story.prototype.displayDefaultTiddlers = function()
+{
+	this.displayTiddlers(null,store.filterTiddlers(store.getTiddlerText("DefaultTiddlers")));
+};
+
+//# Display several tiddlers given their titles in an array. Parameters same as displayTiddler(), except:
+//# titles - array of tiddlers or string titles
+Story.prototype.displayTiddlers = function(srcElement,titles,template,animate,unused,customFields,toggle)
+{
+	var t;
+	for(t = titles.length-1;t>=0;t--)
+		this.displayTiddler(srcElement,titles[t],template,animate,unused,customFields);
+};
+
+//# Display a given tiddler with a given template. If the tiddler is already displayed but with a different
+//# template, it is switched to the specified template. If the tiddler does not exist, and if server hosting
+//# custom fields were provided, then an attempt is made to retrieve the tiddler from the server
+//# srcElement - reference to element from which this one is being opened -or-
+//#              special positions "top", "bottom"
+//# tiddler - tiddler or title of tiddler to display
+//# template - the name of the tiddler containing the template -or-
+//#            one of the constants DEFAULT_VIEW_TEMPLATE and DEFAULT_EDIT_TEMPLATE -or-
+//#            null or undefined to indicate the current template if there is one, DEFAULT_VIEW_TEMPLATE if not
+//# animate - whether to perform animations
+//# customFields - an optional list of name:"value" pairs to be assigned as tiddler fields (for edit templates)
+//# toggle - if true, causes the tiddler to be closed if it is already opened
+//# animationSrc - optional. If provided, this will specify the element which is to act as the start of the animation -or-
+//#                the source of the animation will be the srcElement.
+Story.prototype.displayTiddler = function(srcElement,tiddler,template,animate,unused,customFields,toggle,animationSrc)
+{
+	var title = (tiddler instanceof Tiddler) ? tiddler.title : tiddler;
+	var tiddlerElem = this.getTiddler(title);
+	if(tiddlerElem) {
+		if(toggle) {
+			if(tiddlerElem.getAttribute("dirty") != "true")
+				this.closeTiddler(title,true);
+		} else {
+			this.refreshTiddler(title,template,false,customFields);
+		}
+	} else {
+		var place = this.getContainer();
+		var before = this.positionTiddler(srcElement);
+		tiddlerElem = this.createTiddler(place,before,title,template,customFields);
+	}
+	if(animationSrc && typeof animationSrc !== "string") {
+		srcElement = animationSrc;
+	}
+	if(srcElement && typeof srcElement !== "string") {
+		if(config.options.chkAnimate && (animate == undefined || animate == true) && anim && typeof Zoomer == "function" && typeof Scroller == "function")
+			anim.startAnimating(new Zoomer(title,srcElement,tiddlerElem),new Scroller(tiddlerElem));
+		else
+			window.scrollTo(0,ensureVisible(tiddlerElem));
+	}
+	return tiddlerElem;
+};
+
+//# Figure out the appropriate position for a newly opened tiddler
+//# srcElement - reference to the element containing the link to the tiddler -or-
+//#              special positions "top", "bottom"
+//# returns - reference to the tiddler that the new one should appear before (null for the bottom of the story)
+Story.prototype.positionTiddler = function(srcElement)
+{
+	var place = this.getContainer();
+	var before = null;
+	if(typeof srcElement == "string") {
+		switch(srcElement) {
+		case "top":
+			before = place.firstChild;
+			break;
+		case "bottom":
+			before = null;
+			break;
+		}
+	} else {
+		var after = this.findContainingTiddler(srcElement);
+		if(after == null) {
+			before = place.firstChild;
+		} else if(after.nextSibling) {
+			before = after.nextSibling;
+			if(before.nodeType != 1)
+				before = null;
+		}
+	}
+	return before;
+};
+
+//# Create a tiddler frame at the appropriate place in a story column. If the tiddler doesn't exist,
+//# triggers an attempt to load it as a missing tiddler
+//# place - reference to parent element
+//# before - null, or reference to element before which to insert new tiddler
+//# title - title of new tiddler
+//# template - the name of the tiddler containing the template or one of the constants DEFAULT_VIEW_TEMPLATE and DEFAULT_EDIT_TEMPLATE
+//# customFields - an optional list of name:"value" pairs to be assigned as tiddler fields
+Story.prototype.createTiddler = function(place,before,title,template,customFields)
+{
+	var tiddlerElem = createTiddlyElement(null,"div",this.tiddlerId(title),"tiddler");
+	tiddlerElem.setAttribute("refresh","tiddler");
+	if(customFields)
+		tiddlerElem.setAttribute("tiddlyFields",customFields);
+	place.insertBefore(tiddlerElem,before);
+	var defaultText = null;
+	if(!store.tiddlerExists(title) && !store.isShadowTiddler(title))
+		defaultText = this.loadMissingTiddler(title,customFields);
+	this.refreshTiddler(title,template,false,customFields,defaultText);
+	return tiddlerElem;
+};
+
+//# Attempts to load a missing tiddler from the server specified in the custom fields
+//#   title - title of the missing tiddler
+//#   fields - string of name:"value" pairs or hashmap
+//#   callback - optional function invoked with context argument upon completion; context provides context.tiddler if successful
+Story.prototype.loadMissingTiddler = function(title,fields,callback)
+{
+	var getTiddlerCallback = function(context)
+	{
+		if(context.status) {
+			var t = context.tiddler;
+			if(!t.created)
+				t.created = new Date();
+			if(!t.modified)
+				t.modified = t.created;
+			context.tiddler = store.saveTiddler(t.title,t.title,t.text,t.modifier,t.modified,t.tags,t.fields,true,t.created,t.creator);
+			autoSaveChanges();
+		} else {
+			story.refreshTiddler(context.title,null,true);
+		}
+		context.adaptor.close();
+		if(callback) {
+			callback(context);
+		}
+	};
+	var tiddler = new Tiddler(title);
+	tiddler.fields = typeof fields == "string" ? fields.decodeHashMap() : fields||{};
+	var context = {serverType:tiddler.getServerType()};
+	if(!context.serverType)
+		return "";
+	context.host = tiddler.fields['server.host'];
+	context.workspace = tiddler.fields['server.workspace'];
+	var adaptor = new config.adaptors[context.serverType]();
+	adaptor.getTiddler(title,context,null,getTiddlerCallback);
+	return config.messages.loadingMissingTiddler.format([title,context.serverType,context.host,context.workspace]);
+};
+
+//# Overridable for choosing the name of the template to apply for a tiddler
+Story.prototype.chooseTemplateForTiddler = function(title,template)
+{
+	if(!template)
+		template = DEFAULT_VIEW_TEMPLATE;
+	if(template == DEFAULT_VIEW_TEMPLATE || template == DEFAULT_EDIT_TEMPLATE)
+		template = config.tiddlerTemplates[template];
+	return template;
+};
+
+//# Overridable for extracting the text of a template from a tiddler
+Story.prototype.getTemplateForTiddler = function(title,template,tiddler)
+{
+	return store.getRecursiveTiddlerText(template,null,10);
+};
+
+//# Apply a template to an existing tiddler if it is not already displayed using that template
+//# title - title of tiddler to update
+//# template - the name of the tiddler containing the template or one of the constants DEFAULT_VIEW_TEMPLATE and DEFAULT_EDIT_TEMPLATE
+//# force - if true, forces the refresh even if the template hasn't changed
+//# customFields - an optional list of name/value pairs to be assigned as tiddler fields (for edit templates)
+//# defaultText - an optional string to replace the default text for non-existent tiddlers
+Story.prototype.refreshTiddler = function(title,template,force,customFields,defaultText)
+{
+	var tiddlerElem = this.getTiddler(title);
+	if(tiddlerElem) {
+		if(tiddlerElem.getAttribute("dirty") == "true" && !force)
+			return tiddlerElem;
+		template = this.chooseTemplateForTiddler(title,template);
+		var currTemplate = tiddlerElem.getAttribute("template");
+		if((template != currTemplate) || force) {
+			var tiddler = store.getTiddler(title);
+			if(!tiddler) {
+				tiddler = new Tiddler();
+				if(store.isShadowTiddler(title)) {
+					var tags = [];
+					tiddler.set(title,store.getTiddlerText(title),config.views.wikified.shadowModifier,version.date,tags,version.date);
+				} else {
+					var text = template=="EditTemplate" ?
+								config.views.editor.defaultText.format([title]) :
+								config.views.wikified.defaultText.format([title]);
+					text = defaultText || text;
+					var fields = customFields ? customFields.decodeHashMap() : null;
+					tiddler.set(title,text,config.views.wikified.defaultModifier,version.date,[],version.date,fields);
+				}
+			}
+			tiddlerElem.setAttribute("tags",tiddler.tags.join(" "));
+			tiddlerElem.setAttribute("tiddler",title);
+			tiddlerElem.setAttribute("template",template);
+			tiddlerElem.onmouseover = this.onTiddlerMouseOver;
+			tiddlerElem.onmouseout = this.onTiddlerMouseOut;
+			tiddlerElem.ondblclick = this.onTiddlerDblClick;
+			tiddlerElem[window.event?"onkeydown":"onkeypress"] = this.onTiddlerKeyPress;
+			tiddlerElem.innerHTML = this.getTemplateForTiddler(title,template,tiddler);
+			applyHtmlMacros(tiddlerElem,tiddler);
+			if(store.getTaggedTiddlers(title).length > 0)
+				jQuery(tiddlerElem).addClass("isTag");
+			else
+				jQuery(tiddlerElem).removeClass("isTag");
+			if(store.tiddlerExists(title)) {
+				jQuery(tiddlerElem).removeClass("shadow");
+				jQuery(tiddlerElem).removeClass("missing");
+			} else {
+				jQuery(tiddlerElem).addClass(store.isShadowTiddler(title) ? "shadow" : "missing");
+			}
+			if(customFields)
+				this.addCustomFields(tiddlerElem,customFields);
+		}
+	}
+	return tiddlerElem;
+};
+
+//# Add hidden input elements for the custom fields of a tiddler
+Story.prototype.addCustomFields = function(place,customFields)
+{
+	var fields = customFields.decodeHashMap();
+	var w = createTiddlyElement(place,"div",null,"customFields");
+	w.style.display = "none";
+	var t;
+	for(t in fields) {
+		var e = document.createElement("input");
+		e.setAttribute("type","text");
+		e.setAttribute("value",fields[t]);
+		w.appendChild(e);
+		e.setAttribute("edit",t);
+	}
+};
+
+//# Refresh all tiddlers in the Story
+Story.prototype.refreshAllTiddlers = function(force)
+{
+	var e = this.getContainer().firstChild;
+	while(e) {
+		var template = e.getAttribute("template");
+		if(template && e.getAttribute("dirty") != "true") {
+			this.refreshTiddler(e.getAttribute("tiddler"),force ? null : template,true);
+		}
+		e = e.nextSibling;
+	}
+};
+
+//# Default tiddler onmouseover/out event handlers
+Story.prototype.onTiddlerMouseOver = function(e)
+{
+	jQuery(this).addClass("selected");
+};
+
+Story.prototype.onTiddlerMouseOut = function(e)
+{
+	jQuery(this).removeClass("selected");
+};
+
+//# Default tiddler ondblclick event handler
+Story.prototype.onTiddlerDblClick = function(ev)
+{
+	var e = ev || window.event;
+	var target = resolveTarget(e);
+	if(target && target.nodeName.toLowerCase() != "input" && target.nodeName.toLowerCase() != "textarea") {
+		if(document.selection && document.selection.empty)
+			document.selection.empty();
+		config.macros.toolbar.invokeCommand(this,"defaultCommand",e);
+		e.cancelBubble = true;
+		if(e.stopPropagation) e.stopPropagation();
+		return true;
+	}
+	return false;
+};
+
+Story.prototype.onTiddlerKeyPress = function(ev)
+{
+	var e = ev || window.event;
+	clearMessage();
+	var consume = false;
+	var title = this.getAttribute("tiddler");
+	var target = resolveTarget(e);
+	switch(e.keyCode) {
+	case 9: // Tab
+		var ed = story.getTiddlerField(title,"text");
+		if(target.tagName.toLowerCase() == "input" && ed.value==config.views.editor.defaultText.format([title])) {
+			// moving from input field and editor still contains default text, so select it
+			ed.focus();
+			ed.select();
+			consume = true;
+		}
+		if(config.options.chkInsertTabs && target.tagName.toLowerCase() == "textarea") {
+			replaceSelection(target,String.fromCharCode(9));
+			consume = true;
+		}
+		if(config.isOpera) {
+			target.onblur = function() {
+				this.focus();
+				this.onblur = null;
+			};
+		}
+		break;
+	case 13: // Ctrl-Enter
+	case 10: // Ctrl-Enter on IE PC
+	case 77: // Ctrl-Enter is "M" on some platforms
+		if(e.ctrlKey) {
+			blurElement(this);
+			config.macros.toolbar.invokeCommand(this,"defaultCommand",e);
+			consume = true;
+		}
+		break;
+	case 27: // Escape
+		blurElement(this);
+		config.macros.toolbar.invokeCommand(this,"cancelCommand",e);
+		consume = true;
+		break;
+	}
+	e.cancelBubble = consume;
+	if(consume) {
+		if(e.stopPropagation) e.stopPropagation(); // Stop Propagation
+		e.returnValue = true; // Cancel The Event in IE
+		if(e.preventDefault ) e.preventDefault(); // Cancel The Event in Moz
+	}
+	return !consume;
+};
+
+//# Returns the specified field (input or textarea element) in a tiddler, otherwise the first edit field it finds
+//# or null if it found no edit field at all
+Story.prototype.getTiddlerField = function(title,field)
+{
+	var tiddlerElem = this.getTiddler(title);
+	var e = null;
+	if(tiddlerElem) {
+		var t,children = tiddlerElem.getElementsByTagName("*");
+		for(t=0; t<children.length; t++) {
+			var c = children[t];
+			if(c.tagName.toLowerCase() == "input" || c.tagName.toLowerCase() == "textarea") {
+				if(!e)
+					e = c;
+				if(c.getAttribute("edit") == field)
+					e = c;
+			}
+		}
+	}
+	return e;
+};
+
+//# Focus a specified tiddler. Attempts to focus the specified field, otherwise the first edit field it finds
+Story.prototype.focusTiddler = function(title,field)
+{
+	var e = this.getTiddlerField(title,field);
+	if(e) {
+		e.focus();
+		e.select();
+	}
+};
+
+//# Ensures that a specified tiddler does not have the focus
+Story.prototype.blurTiddler = function(title)
+{
+	var tiddlerElem = this.getTiddler(title);
+	if(tiddlerElem && tiddlerElem.focus && tiddlerElem.blur) {
+		tiddlerElem.focus();
+		tiddlerElem.blur();
+	}
+};
+
+//# Adds a specified value to the edit controls (if any) of a particular
+//# array-formatted field of a particular tiddler (eg "tags")
+//#  title - name of tiddler
+//#  tag - value of field, without any [[brackets]]
+//#  mode - +1 to add the tag, -1 to remove it, 0 to toggle it
+//#  field - name of field (eg "tags")
+Story.prototype.setTiddlerField = function(title,tag,mode,field)
+{
+	var c = this.getTiddlerField(title,field);
+	var tags = c.value.readBracketedList();
+	tags.setItem(tag,mode);
+	c.value = String.encodeTiddlyLinkList(tags);
+};
+
+//# The same as setTiddlerField but preset to the "tags" field
+Story.prototype.setTiddlerTag = function(title,tag,mode)
+{
+	this.setTiddlerField(title,tag,mode,"tags");
+};
+
+//# Close a specified tiddler
+//# title - name of tiddler to close
+//# animate - whether to perform animations
+Story.prototype.closeTiddler = function(title,animate,unused)
+{
+	var tiddlerElem = this.getTiddler(title);
+	if(tiddlerElem) {
+		clearMessage();
+		this.scrubTiddler(tiddlerElem);
+		if(config.options.chkAnimate && animate && anim && typeof Slider == "function")
+			anim.startAnimating(new Slider(tiddlerElem,false,null,"all"));
+		else {
+			jQuery(tiddlerElem).remove();
+		}
+	}
+};
+
+//# Scrub IDs from a tiddler. This is so that the 'ghost' of a tiddler while it is being closed
+//# does not interfere with things
+//# tiddlerElem - reference to the tiddler element
+Story.prototype.scrubTiddler = function(tiddlerElem)
+{
+	tiddlerElem.id = null;
+};
+
+//# Set the 'dirty' flag of a tiddler
+//# title - title of tiddler to change
+//# dirty - new boolean status of flag
+Story.prototype.setDirty = function(title,dirty)
+{
+	var tiddlerElem = this.getTiddler(title);
+	if(tiddlerElem)
+		tiddlerElem.setAttribute("dirty",dirty ? "true" : "false");
+};
+
+//# Is a particular tiddler dirty (with unsaved changes)?
+Story.prototype.isDirty = function(title)
+{
+	var tiddlerElem = this.getTiddler(title);
+	if(tiddlerElem)
+		return tiddlerElem.getAttribute("dirty") == "true";
+	return null;
+};
+
+//# Determine whether any open tiddler are dirty
+Story.prototype.areAnyDirty = function()
+{
+	var r = false;
+	this.forEachTiddler(function(title,element) {
+		if(this.isDirty(title))
+			r = true;
+	});
+	return r;
+};
+
+//# Close all tiddlers in the story
+Story.prototype.closeAllTiddlers = function(exclude)
+{
+	clearMessage();
+	this.forEachTiddler(function(title,element) {
+		if((title != exclude) && element.getAttribute("dirty") != "true")
+			this.closeTiddler(title);
+	});
+	window.scrollTo(0,ensureVisible(this.container));
+};
+
+//# Check if there are any tiddlers in the story
+Story.prototype.isEmpty = function()
+{
+	var place = this.getContainer();
+	return place && place.firstChild == null;
+};
+
+//# Perform a search and display the result
+//# text - text to search for
+//# useCaseSensitive - true for case sensitive matching
+//# useRegExp - true to interpret text as a RegExp
+Story.prototype.search = function(text,useCaseSensitive,useRegExp)
+{
+	this.closeAllTiddlers();
+	highlightHack = new RegExp(useRegExp ? text : text.escapeRegExp(),useCaseSensitive ? "mg" : "img");
+	var matches = store.search(highlightHack,"title","excludeSearch");
+	this.displayTiddlers(null,matches);
+	highlightHack = null;
+	var q = useRegExp ? "/" : "'";
+	if(matches.length > 0)
+		displayMessage(config.macros.search.successMsg.format([matches.length.toString(),q + text + q]));
+	else
+		displayMessage(config.macros.search.failureMsg.format([q + text + q]));
+};
+
+//# Determine if the specified element is within a tiddler in this story
+//# e - reference to an element
+//# returns: reference to a tiddler element or null if none
+Story.prototype.findContainingTiddler = function(e)
+{
+	while(e && !jQuery(e).hasClass("tiddler")) {
+		e = jQuery(e).hasClass("popup") && Popup.stack[0] ? Popup.stack[0].root : e.parentNode;
+	}
+	return e;
+};
+
+//# Gather any saveable fields from a tiddler element
+//# e - reference to an element to scan recursively
+//# fields - object to contain gathered field values
+Story.prototype.gatherSaveFields = function(e,fields)
+{
+	if(e && e.getAttribute) {
+		var f = e.getAttribute("edit");
+		if(f)
+			fields[f] = e.value.replace(/\r/mg,"");
+		if(e.hasChildNodes()) {
+			var t,c = e.childNodes;
+			for(t=0; t<c.length; t++)
+				this.gatherSaveFields(c[t],fields);
+		}
+	}
+};
+
+//# Determine whether a tiddler has any edit fields, and if so if their values have been changed
+//# title - name of tiddler
+Story.prototype.hasChanges = function(title)
+{
+	var e = this.getTiddler(title);
+	if(e) {
+		var fields = {};
+		this.gatherSaveFields(e,fields);
+		if(store.fetchTiddler(title)) {
+		    var n;
+			for(n in fields) {
+				if(store.getValue(title,n) != fields[n]) //# tiddler changed
+					return true;
+			}
+		} else {
+			if(store.isShadowTiddler(title) && store.getShadowTiddlerText(title) == fields.text) { //# not checking for title or tags
+				return false;
+			} else { //# changed shadow or new tiddler
+				return true;
+			}
+		}
+	}
+	return false;
+};
+
+//# Save any open edit fields of a tiddler and updates the display as necessary
+//# title - name of tiddler
+//# minorUpdate - true if the modified date shouldn't be updated
+//# returns: title of saved tiddler, or null if not saved
+Story.prototype.saveTiddler = function(title,minorUpdate)
+{
+	var tiddlerElem = this.getTiddler(title);
+	if(tiddlerElem) {
+		var fields = {};
+		this.gatherSaveFields(tiddlerElem,fields);
+		var newTitle = fields.title || title;
+		if(!store.tiddlerExists(newTitle)) {
+			newTitle = newTitle.trim();
+			var creator = config.options.txtUserName;
+		}
+		if(store.tiddlerExists(newTitle) && newTitle != title) {
+			if(!confirm(config.messages.overwriteWarning.format([newTitle.toString()])))
+				return null;
+				title = newTitle;
+		}
+		if(newTitle != title)
+			this.closeTiddler(newTitle,false);
+		tiddlerElem.id = this.tiddlerId(newTitle);
+		tiddlerElem.setAttribute("tiddler",newTitle);
+		tiddlerElem.setAttribute("template",DEFAULT_VIEW_TEMPLATE);
+		tiddlerElem.setAttribute("dirty","false");
+		if(config.options.chkForceMinorUpdate)
+			minorUpdate = !minorUpdate;
+		if(!store.tiddlerExists(newTitle))
+			minorUpdate = false;
+		var newDate = new Date();
+		if(store.tiddlerExists(title)) {
+			var t = store.fetchTiddler(title);
+			var extendedFields = t.fields;
+			creator = t.creator;
+		} else {
+			extendedFields = merge({},config.defaultCustomFields);
+		}
+		var n;
+		for(n in fields) {
+			if(!TiddlyWiki.isStandardField(n))
+				extendedFields[n] = fields[n];
+		}
+		var tiddler = store.saveTiddler(title,newTitle,fields.text,minorUpdate ? undefined : config.options.txtUserName,minorUpdate ? undefined : newDate,fields.tags,extendedFields,null,null,creator);
+		autoSaveChanges(null,[tiddler]);
+		return newTitle;
+	}
+	return null;
+};
+
+Story.prototype.permaView = function()
+{
+	var links = [];
+	this.forEachTiddler(function(title,element) {
+		links.push(String.encodeTiddlyLink(title));
+	});
+	var t = encodeURIComponent(links.join(" "));
+	if(t == "")
+		t = "#";
+	if(window.location.hash != t)
+		window.location.hash = t;
+};
+
+Story.prototype.switchTheme = function(theme)
+{
+	if(safeMode)
+		return;
+
+	var isAvailable = function(title) {
+		var s = title ? title.indexOf(config.textPrimitives.sectionSeparator) : -1;
+		if(s!=-1)
+			title = title.substr(0,s);
+		return store.tiddlerExists(title) || store.isShadowTiddler(title);
+	};
+
+	var getSlice = function(theme,slice) {
+		var r;
+		if(readOnly)
+			r = store.getTiddlerSlice(theme,slice+"ReadOnly") || store.getTiddlerSlice(theme,"Web"+slice);
+		r = r || store.getTiddlerSlice(theme,slice);
+		if(r && r.indexOf(config.textPrimitives.sectionSeparator)==0)
+			r = theme + r;
+		return isAvailable(r) ? r : slice;
+	};
+
+	var replaceNotification = function(i,name,theme,slice) {
+		var newName = getSlice(theme,slice);
+		if(name!=newName && store.namedNotifications[i].name==name) {
+			store.namedNotifications[i].name = newName;
+			return newName;
+		}
+		return name;
+	};
+
+	var pt = config.refresherData.pageTemplate;
+	var vi = DEFAULT_VIEW_TEMPLATE;
+	var vt = config.tiddlerTemplates[vi];
+	var ei = DEFAULT_EDIT_TEMPLATE;
+	var et = config.tiddlerTemplates[ei];
+
+	var i;
+	for(i=0; i<config.notifyTiddlers.length; i++) {
+		var name = config.notifyTiddlers[i].name;
+		switch(name) {
+		case "PageTemplate":
+			config.refresherData.pageTemplate = replaceNotification(i,config.refresherData.pageTemplate,theme,name);
+			break;
+		case "StyleSheet":
+			removeStyleSheet(config.refresherData.styleSheet);
+			config.refresherData.styleSheet = replaceNotification(i,config.refresherData.styleSheet,theme,name);
+			break;
+		case "ColorPalette":
+			config.refresherData.colorPalette = replaceNotification(i,config.refresherData.colorPalette,theme,name);
+			break;
+		default:
+			break;
+		}
+	}
+	config.tiddlerTemplates[vi] = getSlice(theme,"ViewTemplate");
+	config.tiddlerTemplates[ei] = getSlice(theme,"EditTemplate");
+	if(!startingUp) {
+		if(config.refresherData.pageTemplate!=pt || config.tiddlerTemplates[vi]!=vt || config.tiddlerTemplates[ei]!=et) {
+			refreshAll();
+			this.refreshAllTiddlers(true);
+		} else {
+			setStylesheet(store.getRecursiveTiddlerText(config.refresherData.styleSheet,"",10),config.refreshers.styleSheet);
+		}
+		config.options.txtTheme = theme;
+		saveOption("txtTheme");
+	}
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Strings.js

@@ -0,0 +1,298 @@
+//--
+//-- Augmented methods for the JavaScript String() object
+//--
+
+// Get characters from the right end of a string
+String.prototype.right = function(n)
+{
+	return n < this.length ? this.slice(this.length-n) : this;
+};
+
+// Trim whitespace from both ends of a string
+String.prototype.trim = function()
+{
+	return this.replace(/^\s*|\s*$/g,"");
+};
+
+// Convert a string from a CSS style property name to a JavaScript style name ("background-color" -> "backgroundColor")
+String.prototype.unDash = function()
+{
+	var t,s = this.split("-");
+	if(s.length > 1) {
+		for(t=1; t<s.length; t++)
+			s[t] = s[t].substr(0,1).toUpperCase() + s[t].substr(1);
+	}
+	return s.join("");
+};
+
+// Substitute substrings from an array into a format string that includes '%1'-type specifiers
+String.prototype.format = function(s)
+{
+	var substrings = s && s.constructor == Array ? s : arguments;
+	var subRegExp = /(?:%(\d+))/mg;
+	var currPos = 0;
+	var match,r = [];
+	do {
+		match = subRegExp.exec(this);
+		if(match && match[1]) {
+			if(match.index > currPos)
+				r.push(this.substring(currPos,match.index));
+			r.push(substrings[parseInt(match[1],10)]);
+			currPos = subRegExp.lastIndex;
+		}
+	} while(match);
+	if(currPos < this.length)
+		r.push(this.substring(currPos,this.length));
+	return r.join("");
+};
+
+// Escape any special RegExp characters with that character preceded by a backslash
+String.prototype.escapeRegExp = function()
+{
+	var s = "\\^$*+?()=!|,{}[].";
+	var t,c = this;
+	for(t=0; t<s.length; t++)
+		c = c.replace(new RegExp("\\" + s.substr(t,1),"g"),"\\" + s.substr(t,1));
+	return c;
+};
+
+// Convert "\" to "\s", newlines to "\n" (and remove carriage returns)
+String.prototype.escapeLineBreaks = function()
+{
+	return this.replace(/\\/mg,"\\s").replace(/\n/mg,"\\n").replace(/\r/mg,"");
+};
+
+// Convert "\n" to newlines, "\b" to " ", "\s" to "\" (and remove carriage returns)
+String.prototype.unescapeLineBreaks = function()
+{
+	return this.replace(/\\n/mg,"\n").replace(/\\b/mg," ").replace(/\\s/mg,"\\").replace(/\r/mg,"");
+};
+
+// Convert & to "&amp;", < to "&lt;", > to "&gt;" and " to "&quot;"
+String.prototype.htmlEncode = function()
+{
+	return this.replace(/&/mg,"&amp;").replace(/</mg,"&lt;").replace(/>/mg,"&gt;").replace(/\"/mg,"&quot;");
+};
+
+// Convert "&amp;" to &, "&lt;" to <, "&gt;" to > and "&quot;" to "
+String.prototype.htmlDecode = function()
+{
+	return this.replace(/&lt;/mg,"<").replace(/&gt;/mg,">").replace(/&quot;/mg,"\"").replace(/&amp;/mg,"&");
+};
+
+// Parse a space-separated string of name:value parameters
+//# where:
+//#   - the name or the value can be optional (in which case separate defaults are used instead)
+//#     - in case of ambiguity, a lone word is taken to be a value
+//#     - if 'cascadeDefaults' is set to true, then the defaults are modified by updated by each specified name or value
+//#     - name prefixes are not allowed if the 'noNames' parameter is true
+//#   - if both the name and value are present they must be separated by a colon
+//#   - the name and the value may both be quoted with single- or double-quotes, double-square brackets
+//#   - names or values quoted with {{double-curly braces}} are evaluated as a JavaScript expression
+//#     - as long as the 'allowEval' parameter is true
+// The result is an array of objects:
+//   result[0] = object with a member for each parameter name, value of that member being an array of values
+//   result[1..n] = one object for each parameter, with 'name' and 'value' members
+String.prototype.parseParams = function(defaultName,defaultValue,allowEval,noNames,cascadeDefaults)
+{
+	var parseToken = function(match,p) {
+		var n;
+		if(match[p]) // Double quoted
+			n = match[p];
+		else if(match[p+1]) // Single quoted
+			n = match[p+1];
+		else if(match[p+2]) // Double-square-bracket quoted
+			n = match[p+2];
+		else if(match[p+3]) // Double-brace quoted
+			try {
+				n = match[p+3];
+				if(allowEval && config.evaluateMacroParameters != "none") {
+					if(config.evaluateMacroParameters == "restricted") {
+						if(window.restrictedEval) {
+							n = window.restrictedEval(n);
+						}
+					} else {
+						n = window.eval(n);
+					}
+				}
+			} catch(ex) {
+				throw "Unable to evaluate {{" + match[p+3] + "}}: " + exceptionText(ex);
+			}
+		else if(match[p+4]) // Unquoted
+			n = match[p+4];
+		else if(match[p+5]) // empty quote
+			n = "";
+		return n;
+	};
+	var r = [{}];
+	var dblQuote = "(?:\"((?:(?:\\\\\")|[^\"])+)\")";
+	var sngQuote = "(?:'((?:(?:\\\\\')|[^'])+)')";
+	var dblSquare = "(?:\\[\\[((?:\\s|\\S)*?)\\]\\])";
+	var dblBrace = "(?:\\{\\{((?:\\s|\\S)*?)\\}\\})";
+	var unQuoted = noNames ? "([^\"'\\s]\\S*)" : "([^\"':\\s][^\\s:]*)";
+	var emptyQuote = "((?:\"\")|(?:''))";
+	var skipSpace = "(?:\\s*)";
+	var token = "(?:" + dblQuote + "|" + sngQuote + "|" + dblSquare + "|" + dblBrace + "|" + unQuoted + "|" + emptyQuote + ")";
+	var re = noNames ? new RegExp(token,"mg") : new RegExp(skipSpace + token + skipSpace + "(?:(\\:)" + skipSpace + token + ")?","mg");
+	var match;
+	do {
+		match = re.exec(this);
+		if(match) {
+			var n = parseToken(match,1);
+			if(noNames) {
+				r.push({name:"",value:n});
+			} else {
+				var v = parseToken(match,8);
+				if(v == null && defaultName) {
+					v = n;
+					n = defaultName;
+				} else if(v == null && defaultValue) {
+					v = defaultValue;
+				}
+				r.push({name:n,value:v});
+				if(cascadeDefaults) {
+					defaultName = n;
+					defaultValue = v;
+				}
+			}
+		}
+	} while(match);
+	// Summarise parameters into first element
+	var t;
+	for(t=1; t<r.length; t++) {
+		if(r[0][r[t].name])
+			r[0][r[t].name].push(r[t].value);
+		else
+			r[0][r[t].name] = [r[t].value];
+	}
+	return r;
+};
+
+// Process a string list of macro parameters into an array. Parameters can be quoted with "", '',
+// [[]], {{ }} or left unquoted (and therefore space-separated). Double-braces {{}} results in
+// an *evaluated* parameter: e.g. {{config.options.txtUserName}} results in the current user's name.
+String.prototype.readMacroParams = function(notAllowEval)
+{
+	var p = this.parseParams("list",null,!notAllowEval,true);
+	var t,n = [];
+	for(t=1; t<p.length; t++)
+		n.push(p[t].value);
+	return n;
+};
+
+// Process a string list of unique tiddler names into an array. Tiddler names that have spaces in them must be [[bracketed]]
+String.prototype.readBracketedList = function(unique)
+{
+	var p = this.parseParams("list",null,false,true);
+	var t,n = [];
+	for(t=1; t<p.length; t++) {
+		if(p[t].value)
+			n.pushUnique(p[t].value,unique);
+	}
+	return n;
+};
+
+// Returns array with start and end index of chunk between given start and end marker, or undefined.
+String.prototype.getChunkRange = function(start,end)
+{
+	var s = this.indexOf(start);
+	if(s != -1) {
+		s += start.length;
+		var e = this.indexOf(end,s);
+		if(e != -1)
+			return [s,e];
+	}
+};
+
+// Replace a chunk of a string given start and end markers
+String.prototype.replaceChunk = function(start,end,sub)
+{
+	var r = this.getChunkRange(start,end);
+	return r ? this.substring(0,r[0]) + sub + this.substring(r[1]) : this;
+};
+
+// Returns a chunk of a string between start and end markers, or undefined
+String.prototype.getChunk = function(start,end)
+{
+	var r = this.getChunkRange(start,end);
+	if(r)
+		return this.substring(r[0],r[1]);
+};
+
+
+// Static method to bracket a string with double square brackets if it contains a space
+String.encodeTiddlyLink = function(title)
+{
+	return title.indexOf(" ") == -1 ? title : "[[" + title + "]]";
+};
+
+// Static method to encodeTiddlyLink for every item in an array and join them with spaces
+String.encodeTiddlyLinkList = function(list)
+{
+	if(list) {
+		var t,results = [];
+		for(t=0; t<list.length; t++)
+			results.push(String.encodeTiddlyLink(list[t]));
+		return results.join(" ");
+	} else {
+		return "";
+	}
+};
+
+// Convert a string as a sequence of name:"value" pairs into a hashmap
+String.prototype.decodeHashMap = function()
+{
+	var fields = this.parseParams("anon","",false);
+	var t,r = {};
+	for(t=1; t<fields.length; t++)
+		r[fields[t].name] = fields[t].value;
+	return r;
+};
+
+// Static method to encode a hashmap into a name:"value"... string
+String.encodeHashMap = function(hashmap)
+{
+	var t,r = [];
+	for(t in hashmap)
+		r.push(t + ':"' + hashmap[t] + '"');
+	return r.join(" ");
+};
+
+// Static method to left-pad a string with 0s to a certain width
+String.zeroPad = function(n,d)
+{
+	var s = n.toString();
+	if(s.length < d)
+		s = "000000000000000000000000000".substr(0,d-s.length) + s;
+	return s;
+};
+
+String.prototype.startsWith = function(prefix)
+{
+	return !prefix || this.substring(0,prefix.length) == prefix;
+};
+
+// Returns the first value of the given named parameter.
+//#
+//# @param params
+//#         as returned by parseParams or null/undefined
+//# @return [may be null/undefined]
+//#
+function getParam(params,name,defaultValue)
+{
+	if(!params)
+		return defaultValue;
+	var p = params[0][name];
+	return p ? p[0] : defaultValue;
+}
+
+// Returns the first value of the given boolean named parameter.
+//#
+//# @param params
+//#         as returned by parseParams or null/undefined
+//#
+function getFlag(params,name,defaultValue)
+{
+	return !!getParam(params,name,defaultValue);
+}
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Sync.js

@@ -0,0 +1,222 @@
+//--
+//-- Sync macro
+//--
+
+// Synchronisation handlers
+config.syncers = {};
+
+// Sync state.
+//# Members:
+//#	syncList - List of sync objects (title, tiddler, server, workspace, page, revision)
+//#	wizard - reference to wizard object
+//#	listView - DOM element of the listView table
+var currSync = null;
+
+// sync macro
+config.macros.sync.handler = function(place,macroName,params,wikifier,paramString,tiddler)
+{
+	if(!wikifier.isStatic)
+		this.startSync(place);
+};
+
+config.macros.sync.cancelSync = function()
+{
+	currSync = null;
+};
+
+config.macros.sync.startSync = function(place)
+{
+	if(currSync)
+		config.macros.sync.cancelSync();
+	currSync = {};
+	currSync.syncList = this.getSyncableTiddlers();
+	currSync.syncTasks = this.createSyncTasks(currSync.syncList);
+	this.preProcessSyncableTiddlers(currSync.syncList);
+	var wizard = new Wizard();
+	currSync.wizard = wizard;
+	wizard.createWizard(place,this.wizardTitle);
+	wizard.addStep(this.step1Title,this.step1Html);
+	var markList = wizard.getElement("markList");
+	var listWrapper = document.createElement("div");
+	markList.parentNode.insertBefore(listWrapper,markList);
+	currSync.listView = ListView.create(listWrapper,currSync.syncList,this.listViewTemplate);
+	this.processSyncableTiddlers(currSync.syncList);
+	wizard.setButtons([{caption: this.syncLabel, tooltip: this.syncPrompt, onClick: this.doSync}]);
+};
+
+config.macros.sync.getSyncableTiddlers = function()
+{
+	var list = [];
+	store.forEachTiddler(function(title,tiddler) {
+		var syncItem = {};
+		syncItem.serverType = tiddler.getServerType();
+		syncItem.serverHost = tiddler.fields['server.host'];
+		if(syncItem.serverType && syncItem.serverHost) {
+			syncItem.adaptor = new config.adaptors[syncItem.serverType]();
+			syncItem.serverHost = syncItem.adaptor.fullHostName(syncItem.serverHost);
+			syncItem.serverWorkspace = tiddler.fields['server.workspace'];
+			syncItem.tiddler = tiddler;
+			syncItem.title = tiddler.title;
+			syncItem.isTouched = tiddler.isTouched();
+			syncItem.selected = syncItem.isTouched;
+			syncItem.syncStatus = config.macros.sync.syncStatusList[syncItem.isTouched ? "changedLocally" : "none"];
+			syncItem.status = syncItem.syncStatus.text;
+			list.push(syncItem);
+		}
+		});
+	list.sort(function(a,b) {return a.title < b.title ? -1 : (a.title == b.title ? 0 : +1);});
+	return list;
+};
+
+config.macros.sync.preProcessSyncableTiddlers = function(syncList)
+{
+	var i;
+	for(i=0; i<syncList.length; i++) {
+		var si = syncList[i];
+		si.serverUrl = si.adaptor.generateTiddlerInfo(si.tiddler).uri;
+	}
+};
+
+config.macros.sync.processSyncableTiddlers = function(syncList)
+{
+	var i;
+	for(i=0; i<syncList.length; i++) {
+		var si = syncList[i];
+		if(si.syncStatus.display)
+			si.rowElement.style.display = si.syncStatus.display;
+		if(si.syncStatus.className)
+			si.rowElement.className = si.syncStatus.className;
+	}
+};
+
+config.macros.sync.createSyncTasks = function(syncList)
+{
+	var i,syncTasks = [];
+	for(i=0; i<syncList.length; i++) {
+		var si = syncList[i];
+		var j,r = null;
+		for(j=0; j<syncTasks.length; j++) {
+			var cst = syncTasks[j];
+			if(si.serverType == cst.serverType && si.serverHost == cst.serverHost && si.serverWorkspace == cst.serverWorkspace)
+				r = cst;
+		}
+		if(r) {
+			si.syncTask = r;
+			r.syncItems.push(si);
+		} else {
+			si.syncTask = this.createSyncTask(si);
+			syncTasks.push(si.syncTask);
+		}
+	}
+	return syncTasks;
+};
+
+config.macros.sync.createSyncTask = function(syncItem)
+{
+	var st = {};
+	st.serverType = syncItem.serverType;
+	st.serverHost = syncItem.serverHost;
+	st.serverWorkspace = syncItem.serverWorkspace;
+	st.syncItems = [syncItem];
+
+	var getTiddlerListCallback = function(context,sycnItems) {
+		var me = config.macros.sync;
+		if(!context.status) {
+			displayMessage(context.statusText);
+			return false;
+		}
+		syncItems = context.userParams;
+		var i,tiddlers = context.tiddlers;
+		for(i=0; i<syncItems.length; i++) {
+			var si = syncItems[i];
+			var f = tiddlers.findByField("title",si.title);
+			if(f !== null) {
+				if(tiddlers[f].fields['server.page.revision'] > si.tiddler.fields['server.page.revision']) {
+					si.syncStatus = me.syncStatusList[si.isTouched ? 'changedBoth' : 'changedServer'];
+				}
+			} else {
+				si.syncStatus = me.syncStatusList.notFound;
+			}
+			me.updateSyncStatus(si);
+		}
+		return true;
+	};
+
+	var openWorkspaceCallback = function(context,syncItems) {
+		if(context.status) {
+			context.adaptor.getTiddlerList(context,syncItems,getTiddlerListCallback);
+			return true;
+		}
+		displayMessage(context.statusText);
+		return false;
+	};
+
+	var context = {host:st.serverHost,workspace:st.serverWorkspace};
+	syncItem.adaptor.openHost(st.serverHost);
+	syncItem.adaptor.openWorkspace(st.serverWorkspace,context,st.syncItems,openWorkspaceCallback);
+	return st;
+};
+
+config.macros.sync.updateSyncStatus = function(syncItem)
+{
+	var e = syncItem.colElements["status"];
+	jQuery(e).empty();
+	createTiddlyText(e,syncItem.syncStatus.text);
+	syncItem.rowElement.style.display = syncItem.syncStatus.display;
+	if(syncItem.syncStatus.className)
+		syncItem.rowElement.className = syncItem.syncStatus.className;
+};
+
+config.macros.sync.doSync = function(e)
+{
+	var me = config.macros.sync;
+	var getTiddlerCallback = function(context,syncItem) {
+		if(syncItem) {
+			var tiddler = context.tiddler;
+			store.saveTiddler(tiddler.title,tiddler.title,tiddler.text,tiddler.modifier,tiddler.modified,tiddler.tags,tiddler.fields,true,tiddler.created);
+			syncItem.syncStatus = me.syncStatusList.gotFromServer;
+			me.updateSyncStatus(syncItem);
+		}
+	};
+	var putTiddlerCallback = function(context,syncItem) {
+		if(syncItem) {
+			store.resetTiddler(context.title);
+			syncItem.syncStatus = me.syncStatusList.putToServer;
+			me.updateSyncStatus(syncItem);
+		}
+	};
+
+	var rowNames = ListView.getSelectedRows(currSync.listView);
+	var i,sl = me.syncStatusList;
+	for(i=0; i<currSync.syncList.length; i++) {
+		var si = currSync.syncList[i];
+		if(rowNames.indexOf(si.title) != -1) {
+			var errorMsg = "Error in doSync: ";
+			try {
+				var r = true;
+				switch(si.syncStatus) {
+				case sl.changedServer:
+					var context = {"workspace": si.serverWorkspace};
+					r = si.adaptor.getTiddler(si.title,context,si,getTiddlerCallback);
+					break;
+				case sl.notFound:
+				case sl.changedLocally:
+				case sl.changedBoth:
+					r = si.adaptor.putTiddler(si.tiddler,null,si,putTiddlerCallback);
+					break;
+				default:
+					break;
+				}
+				if(!r)
+					displayMessage(errorMsg + r);
+			} catch(ex) {
+				if(ex.name == "TypeError")
+					displayMessage("sync operation unsupported: " + ex.message);
+				else
+					displayMessage(errorMsg + ex.message);
+			}
+		}
+	}
+	return false;
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/TW21Loader.js

@@ -0,0 +1,55 @@
+//--
+//-- TW21Loader (inherits from LoaderBase)
+//--
+
+function TW21Loader() {}
+
+TW21Loader.prototype = new LoaderBase();
+
+TW21Loader.prototype.getTitle = function(store,node)
+{
+	var title = null;
+	if(node.getAttribute) {
+		title = node.getAttribute("title");
+		if(!title)
+			title = node.getAttribute("tiddler");
+	}
+	if(!title && node.id) {
+		var lenPrefix = store.idPrefix.length;
+		if(node.id.substr(0,lenPrefix) == store.idPrefix)
+			title = node.id.substr(lenPrefix);
+	}
+	return title;
+};
+
+TW21Loader.prototype.internalizeTiddler = function(store,tiddler,title,node)
+{
+	var e = node.firstChild;
+	var text = null;
+	if(node.getAttribute("tiddler")) {
+		text = getNodeText(e).unescapeLineBreaks();
+	} else {
+		while(e.nodeName!="PRE" && e.nodeName!="pre") {
+			e = e.nextSibling;
+		}
+		text = e.innerHTML.replace(/\r/mg,"").htmlDecode();
+	}
+	var creator = node.getAttribute("creator");
+	var modifier = node.getAttribute("modifier");
+	var c = node.getAttribute("created");
+	var m = node.getAttribute("modified");
+	var created = c ? Date.convertFromYYYYMMDDHHMMSS(c) : version.date;
+	var modified = m ? Date.convertFromYYYYMMDDHHMMSS(m) : created;
+	var tags = node.getAttribute("tags");
+	var fields = {};
+	var i,attrs = node.attributes;
+	for(i = attrs.length-1; i >= 0; i--) {
+		var name = attrs[i].name;
+		if(attrs[i].specified && !TiddlyWiki.isStandardField(name)) {
+			fields[name] = attrs[i].value.unescapeLineBreaks();
+		}
+	}
+	tiddler.assign(title,text,modifier,modified,tags,created,fields,creator);
+	return tiddler;
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/TW21Saver.js

@@ -0,0 +1,42 @@
+//--
+//-- TW21Saver (inherits from SaverBase)
+//--
+
+function TW21Saver() {}
+
+TW21Saver.prototype = new SaverBase();
+
+TW21Saver.prototype.externalizeTiddler = function(store,tiddler)
+{
+	try {
+		var extendedAttributes = "";
+		var usePre = config.options.chkUsePreForStorage;
+		store.forEachField(tiddler,
+			function(tiddler,fieldName,value) {
+				// don't store stuff from the temp namespace
+				if(typeof value != "string")
+					value = "";
+				if(!fieldName.match(/^temp\./))
+					extendedAttributes += ' %0="%1"'.format([fieldName,value.escapeLineBreaks().htmlEncode()]);
+			},true);
+		var created = tiddler.created;
+		var modified = tiddler.modified;
+		var attributes = tiddler.creator ? ' creator="' + tiddler.creator.htmlEncode() + '"' : "";
+		attributes += tiddler.modifier ? ' modifier="' + tiddler.modifier.htmlEncode() + '"' : "";
+		attributes += (usePre && created == version.date) ? "" :' created="' + created.convertToYYYYMMDDHHMM() + '"';
+		attributes += (usePre && modified == created) ? "" : ' modified="' + modified.convertToYYYYMMDDHHMM() +'"';
+		var tags = tiddler.getTags();
+		if(!usePre || tags)
+			attributes += ' tags="' + tags.htmlEncode() + '"';
+		return ('<div %0="%1"%2%3>%4</'+'div>').format([
+				usePre ? "title" : "tiddler",
+				tiddler.title.htmlEncode(),
+				attributes,
+				extendedAttributes,
+				usePre ? "\n<pre>" + tiddler.text.htmlEncode() + "</pre>\n" : tiddler.text.escapeLineBreaks().htmlEncode()
+			]);
+	} catch (ex) {
+		throw exceptionText(ex,config.messages.tiddlerSaveError.format([tiddler.title]));
+	}
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Tabs.js

@@ -0,0 +1,65 @@
+//--
+//-- Tabs macro
+//--
+
+config.macros.tabs.handler = function(place,macroName,params)
+{
+	var cookie = params[0];
+	var numTabs = (params.length-1)/3;
+	var wrapper = createTiddlyElement(null,"div",null,"tabsetWrapper " + cookie);
+	var tabset = createTiddlyElement(wrapper,"div",null,"tabset");
+	tabset.setAttribute("cookie",cookie);
+	var validTab = false;
+	var t;
+	for(t=0; t<numTabs; t++) {
+		var label = params[t*3+1];
+		var prompt = params[t*3+2];
+		var content = params[t*3+3];
+		var tab = createTiddlyButton(tabset,label,prompt,this.onClickTab,"tab tabUnselected");
+		createTiddlyElement(tab,"span",null,null," ",{style:"font-size:0pt;line-height:0px"});
+		tab.setAttribute("tab",label);
+		tab.setAttribute("content",content);
+		tab.title = prompt;
+		if(config.options[cookie] == label)
+			validTab = true;
+	}
+	if(!validTab)
+		config.options[cookie] = params[1];
+	place.appendChild(wrapper);
+	this.switchTab(tabset,config.options[cookie]);
+};
+
+config.macros.tabs.onClickTab = function(e)
+{
+	config.macros.tabs.switchTab(this.parentNode,this.getAttribute("tab"));
+	return false;
+};
+
+config.macros.tabs.switchTab = function(tabset,tab)
+{
+	var cookie = tabset.getAttribute("cookie");
+	var theTab = null;
+	var nodes = tabset.childNodes;
+	var t;
+	for(t=0; t<nodes.length; t++) {
+		if(nodes[t].getAttribute && nodes[t].getAttribute("tab") == tab) {
+			theTab = nodes[t];
+			theTab.className = "tab tabSelected";
+		} else {
+			nodes[t].className = "tab tabUnselected";
+		}
+	}
+	if(theTab) {
+		if(tabset.nextSibling && tabset.nextSibling.className == "tabContents")
+			jQuery(tabset.nextSibling).remove();
+		var tabContent = createTiddlyElement(null,"div",null,"tabContents");
+		tabset.parentNode.insertBefore(tabContent,tabset.nextSibling);
+		var contentTitle = theTab.getAttribute("content");
+		wikify(store.getTiddlerText(contentTitle),tabContent,null,store.getTiddler(contentTitle));
+		if(cookie) {
+			config.options[cookie] = tab;
+			saveOption(cookie);
+		}
+	}
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Tiddler.js

@@ -0,0 +1,207 @@
+//--
+//-- Tiddler() object
+//--
+
+function Tiddler(title)
+{
+	this.title = title;
+	this.text = "";
+	this.creator = null;
+	this.modifier = null;
+	this.created = new Date();
+	this.modified = this.created;
+	this.links = [];
+	this.linksUpdated = false;
+	this.tags = [];
+	this.fields = {};
+	return this;
+}
+
+Tiddler.prototype.getLinks = function()
+{
+	if(this.linksUpdated==false)
+		this.changed();
+	return this.links;
+};
+
+// Returns the fields that are inherited in string field:"value" field2:"value2" format
+Tiddler.prototype.getInheritedFields = function()
+{
+	var f = {};
+	var i;
+	for(i in this.fields) {
+		if(i=="server.host" || i=="server.workspace" || i=="wikiformat"|| i=="server.type") {
+			f[i] = this.fields[i];
+		}
+	}
+	return String.encodeHashMap(f);
+};
+
+// Increment the changeCount of a tiddler
+Tiddler.prototype.incChangeCount = function()
+{
+	var c = this.fields['changecount'];
+	c = c ? parseInt(c,10) : 0;
+	this.fields['changecount'] = String(c+1);
+};
+
+// Clear the changeCount of a tiddler
+Tiddler.prototype.clearChangeCount = function()
+{
+	if(this.fields['changecount']) {
+		delete this.fields['changecount'];
+	}
+};
+
+//# returns true when this tiddler has the field 'temporary', meaning it is a temporary tiddler (i.e. must not be saved).
+Tiddler.prototype.doNotSave = function()
+{
+	return this.fields['doNotSave'];
+};
+
+// Returns true if the tiddler has been updated since the tiddler was created or downloaded
+Tiddler.prototype.isTouched = function()
+{
+	var changecount = this.fields.changecount || 0;
+	return changecount > 0;
+};
+
+// Change the text and other attributes of a tiddler
+Tiddler.prototype.set = function(title,text,modifier,modified,tags,created,fields,creator)
+{
+	this.assign(title,text,modifier,modified,tags,created,fields,creator);
+	this.changed();
+	return this;
+};
+
+// Change the text and other attributes of a tiddler without triggered a tiddler.changed() call
+Tiddler.prototype.assign = function(title,text,modifier,modified,tags,created,fields,creator)
+{
+	if(title != undefined)
+		this.title = title;
+	if(text != undefined)
+		this.text = text;
+	if(modifier != undefined)
+		this.modifier = modifier;
+	if(modified != undefined)
+		this.modified = modified;
+	if(creator != undefined)
+		this.creator = creator;
+	if(created != undefined)
+		this.created = created;
+	if(fields != undefined)
+		this.fields = fields;
+	if(tags != undefined)
+		this.tags = (typeof tags == "string") ? tags.readBracketedList() : tags;
+	else if(this.tags == undefined)
+		this.tags = [];
+	return this;
+};
+
+// Get the tags for a tiddler as a string (space delimited, using [[brackets]] for tags containing spaces)
+Tiddler.prototype.getTags = function()
+{
+	return String.encodeTiddlyLinkList(this.tags);
+};
+
+// Test if a tiddler carries a tag
+Tiddler.prototype.isTagged = function(tag)
+{
+	return this.tags.indexOf(tag) != -1;
+};
+
+// Static method to convert "\n" to newlines, "\s" to "\"
+Tiddler.unescapeLineBreaks = function(text)
+{
+	return text ? text.unescapeLineBreaks() : "";
+};
+
+// Convert newlines to "\n", "\" to "\s"
+Tiddler.prototype.escapeLineBreaks = function()
+{
+	return this.text.escapeLineBreaks();
+};
+
+// Updates the secondary information (like links[] array) after a change to a tiddler
+Tiddler.prototype.changed = function()
+{
+	this.links = [];
+	var text = this.text;
+	// remove 'quoted' text before scanning tiddler source
+	text = text.replace(/\/%((?:.|\n)*?)%\//g,"").
+		replace(/\{{3}((?:.|\n)*?)\}{3}/g,"").
+		replace(/"""((?:.|\n)*?)"""/g,"").
+		replace(/<nowiki\>((?:.|\n)*?)<\/nowiki\>/g,"").
+		replace(/<html\>((?:.|\n)*?)<\/html\>/g,"").
+		replace(/<script((?:.|\n)*?)<\/script\>/g,"");
+	var t = this.autoLinkWikiWords() ? 0 : 1;
+	var tiddlerLinkRegExp = t==0 ? config.textPrimitives.tiddlerAnyLinkRegExp : config.textPrimitives.tiddlerForcedLinkRegExp;
+	tiddlerLinkRegExp.lastIndex = 0;
+	var formatMatch = tiddlerLinkRegExp.exec(text);
+	while(formatMatch) {
+		var lastIndex = tiddlerLinkRegExp.lastIndex;
+		if(t==0 && formatMatch[1] && formatMatch[1] != this.title) {
+			// wikiWordLink
+			if(formatMatch.index > 0) {
+				var preRegExp = new RegExp(config.textPrimitives.unWikiLink+"|"+config.textPrimitives.anyLetter,"mg");
+				preRegExp.lastIndex = formatMatch.index-1;
+				var preMatch = preRegExp.exec(text);
+				if(preMatch.index != formatMatch.index-1)
+					this.links.pushUnique(formatMatch[1]);
+			} else {
+				this.links.pushUnique(formatMatch[1]);
+			}
+		}
+		else if(formatMatch[2-t] && !config.formatterHelpers.isExternalLink(formatMatch[3-t])) // titledBrackettedLink
+			this.links.pushUnique(formatMatch[3-t]);
+		else if(formatMatch[4-t] && formatMatch[4-t] != this.title) // brackettedLink
+			this.links.pushUnique(formatMatch[4-t]);
+		//# Do not add link if match urlPattern (formatMatch[5-t])
+		tiddlerLinkRegExp.lastIndex = lastIndex;
+		formatMatch = tiddlerLinkRegExp.exec(text);
+	}
+	this.linksUpdated = true;
+};
+
+Tiddler.prototype.getSubtitle = function()
+{
+	var modifier = this.modifier;
+	if(!modifier)
+		modifier = config.messages.subtitleUnknown || "";
+	var modified = this.modified;
+	if(modified)
+		modified = modified.toLocaleString();
+	else
+		modified = config.messages.subtitleUnknown || "";
+	var f = config.messages.tiddlerLinkTooltip || "%0 - %1, %2";
+	return f.format([this.title,modifier,modified]);
+};
+
+Tiddler.prototype.isReadOnly = function()
+{
+	return readOnly;
+};
+
+Tiddler.prototype.autoLinkWikiWords = function()
+{
+	return !(this.isTagged("systemConfig") || this.isTagged("excludeMissing"));
+};
+
+Tiddler.prototype.getServerType = function()
+{
+	var serverType = null;
+	if(this.fields['server.type'])
+		serverType = this.fields['server.type'];
+	if(!serverType)
+		serverType = this.fields['wikiformat'];
+	if(serverType && !config.adaptors[serverType])
+		serverType = null;
+	return serverType;
+};
+
+Tiddler.prototype.getAdaptor = function()
+{
+	var serverType = this.getServerType();
+	return serverType ? new config.adaptors[serverType]() : null;
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/TiddlerFields.js

@@ -0,0 +1,173 @@
+// Returns true if path is a valid field name (path),
+// i.e. a sequence of identifiers, separated by "."
+TiddlyWiki.isValidFieldName = function(name)
+{
+	var match = /[a-zA-Z_]\w*(\.[a-zA-Z_]\w*)*/.exec(name);
+	return match && (match[0] == name);
+};
+
+// Throws an exception when name is not a valid field name.
+TiddlyWiki.checkFieldName = function(name)
+{
+	if(!TiddlyWiki.isValidFieldName(name))
+		throw config.messages.invalidFieldName.format([name]);
+};
+
+function StringFieldAccess(n,readOnly)
+{
+	this.set = readOnly ?
+			function(t,v) {if(v != t[n]) throw config.messages.fieldCannotBeChanged.format([n]);} :
+			function(t,v) {if(v != t[n]) {t[n] = v; return true;}};
+	this.get = function(t) {return t[n];};
+}
+
+function DateFieldAccess(n)
+{
+	this.set = function(t,v) {
+		var d = v instanceof Date ? v : Date.convertFromYYYYMMDDHHMM(v);
+		if(d != t[n]) {
+			t[n] = d; return true;
+		}
+	};
+	this.get = function(t) {return t[n].convertToYYYYMMDDHHMM();};
+}
+
+function LinksFieldAccess(n)
+{
+	this.set = function(t,v) {
+		var s = (typeof v == "string") ? v.readBracketedList() : v;
+		if(s.toString() != t[n].toString()) {
+			t[n] = s; return true;
+		}
+	};
+	this.get = function(t) {return String.encodeTiddlyLinkList(t[n]);};
+}
+
+TiddlyWiki.standardFieldAccess = {
+	// The set functions return true when setting the data has changed the value.
+	"title":    new StringFieldAccess("title",true),
+	// Handle the "tiddler" field name as the title
+	"tiddler":  new StringFieldAccess("title",true),
+	"text":     new StringFieldAccess("text"),
+	"modifier": new StringFieldAccess("modifier"),
+	"modified": new DateFieldAccess("modified"),
+	"creator":  new StringFieldAccess("creator"),
+	"created":  new DateFieldAccess("created"),
+	"tags":     new LinksFieldAccess("tags")
+};
+
+TiddlyWiki.isStandardField = function(name)
+{
+	return TiddlyWiki.standardFieldAccess[name] != undefined;
+};
+
+// Sets the value of the given field of the tiddler to the value.
+// Setting an ExtendedField's value to null or undefined removes the field.
+// Setting a namespace to undefined removes all fields of that namespace.
+// The fieldName is case-insensitive.
+// All values will be converted to a string value.
+TiddlyWiki.prototype.setValue = function(tiddler,fieldName,value)
+{
+	TiddlyWiki.checkFieldName(fieldName);
+	var t = this.resolveTiddler(tiddler);
+	if(!t)
+		return;
+	fieldName = fieldName.toLowerCase();
+	var isRemove = (value === undefined) || (value === null);
+	var accessor = TiddlyWiki.standardFieldAccess[fieldName];
+	if(accessor) {
+		if(isRemove)
+			// don't remove StandardFields
+			return;
+		var h = TiddlyWiki.standardFieldAccess[fieldName];
+		if(!h.set(t,value))
+			return;
+	} else {
+		var oldValue = t.fields[fieldName];
+		if(isRemove) {
+			if(oldValue !== undefined) {
+				// deletes a single field
+				delete t.fields[fieldName];
+			} else {
+				// no concrete value is defined for the fieldName
+				// so we guess this is a namespace path.
+				// delete all fields in a namespace
+				var re = new RegExp("^"+fieldName+"\\.");
+				var dirty = false;
+				var n;
+				for(n in t.fields) {
+					if(n.match(re)) {
+						delete t.fields[n];
+						dirty = true;
+					}
+				}
+				if(!dirty)
+					return;
+			}
+		} else {
+			// the "normal" set case. value is defined (not null/undefined)
+			// For convenience provide a nicer conversion Date->String
+			value = value instanceof Date ? value.convertToYYYYMMDDHHMMSSMMM() : String(value);
+			if(oldValue == value)
+				return;
+			t.fields[fieldName] = value;
+		}
+	}
+	// When we are here the tiddler/store really was changed.
+	this.notify(t.title,true);
+	if(!fieldName.match(/^temp\./))
+		this.setDirty(true);
+};
+
+// Returns the value of the given field of the tiddler.
+// The fieldName is case-insensitive.
+// Will only return String values (or undefined).
+TiddlyWiki.prototype.getValue = function(tiddler,fieldName)
+{
+	var t = this.resolveTiddler(tiddler);
+	if(!t)
+		return undefined;
+	if(fieldName.indexOf(config.textPrimitives.sectionSeparator) === 0 || fieldName.indexOf(config.textPrimitives.sliceSeparator) === 0) {
+		var sliceType = fieldName.substr(0, 2);
+		var sliceName = fieldName.substring(2);
+		return store.getTiddlerText("%0%1%2".format(t.title,sliceType,sliceName));
+	} else {
+		fieldName = fieldName.toLowerCase();
+		var accessor = TiddlyWiki.standardFieldAccess[fieldName];
+		if(accessor) {
+			return accessor.get(t);
+		}
+	}
+	return t.fields[fieldName];
+};
+
+// Calls the callback function for every field in the tiddler.
+// When callback function returns a non-false value the iteration stops
+// and that value is returned.
+// The order of the fields is not defined.
+// @param callback a function(tiddler,fieldName,value).
+TiddlyWiki.prototype.forEachField = function(tiddler,callback,onlyExtendedFields)
+{
+	var t = this.resolveTiddler(tiddler);
+	if(!t)
+		return undefined;
+	var n,result;
+	for(n in t.fields) {
+		result = callback(t,n,t.fields[n]);
+		if(result)
+			return result;
+		}
+	if(onlyExtendedFields)
+		return undefined;
+	for(n in TiddlyWiki.standardFieldAccess) {
+		if(n != "tiddler") {
+			// even though the "title" field can also be referenced through the name "tiddler"
+			// we only visit this field once.
+			result = callback(t,n,TiddlyWiki.standardFieldAccess[n].get(t));
+			if(result)
+				return result;
+		}
+	}
+	return undefined;
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/TiddlyWiki.js

@@ -0,0 +1,645 @@
+//--
+//-- TiddlyWiki instance contains TiddlerS
+//--
+
+function TiddlyWiki(params)
+{
+	var tiddlers = {}; // Hashmap by name of tiddlers
+	if(params && params.config) {
+		this.config = config;
+	}
+	this.tiddlersUpdated = false;
+	this.namedNotifications = []; // Array of {name:,notify:} of notification functions
+	this.notificationLevel = 0;
+	this.slices = {}; // map tiddlerName->(map sliceName->sliceValue). Lazy.
+	this.clear = function() {
+		tiddlers = {};
+		this.setDirty(false);
+	};
+	this.fetchTiddler = function(title) {
+		var t = tiddlers[title];
+		return t instanceof Tiddler ? t : null;
+	};
+	this.deleteTiddler = function(title) {
+		delete this.slices[title];
+		delete tiddlers[title];
+	};
+	this.addTiddler = function(tiddler) {
+		delete this.slices[tiddler.title];
+		tiddlers[tiddler.title] = tiddler;
+	};
+	this.forEachTiddler = function(callback) {
+		var t;
+		for(t in tiddlers) {
+			var tiddler = tiddlers[t];
+			if(tiddler instanceof Tiddler)
+				callback.call(this,t,tiddler);
+		}
+	};
+}
+
+//# Set the dirty flag
+TiddlyWiki.prototype.setDirty = function(dirty)
+{
+	this.dirty = dirty;
+};
+
+TiddlyWiki.prototype.isDirty = function()
+{
+	return this.dirty;
+};
+
+TiddlyWiki.prototype.tiddlerExists = function(title)
+{
+	var t = this.fetchTiddler(title);
+	return t != undefined;
+};
+
+TiddlyWiki.prototype.isShadowTiddler = function(title)
+{
+	return config.shadowTiddlers[title] === undefined ? false : true;
+};
+
+TiddlyWiki.prototype.createTiddler = function(title)
+{
+	var tiddler = this.fetchTiddler(title);
+	if(!tiddler) {
+		tiddler = new Tiddler(title);
+		this.addTiddler(tiddler);
+		this.setDirty(true);
+	}
+	return tiddler;
+};
+
+TiddlyWiki.prototype.getTiddler = function(title)
+{
+	var t = this.fetchTiddler(title);
+	if(t != undefined)
+		return t;
+	else
+		return null;
+};
+
+TiddlyWiki.prototype.getShadowTiddlerText = function(title)
+{
+	if(typeof config.shadowTiddlers[title] == "string")
+		return config.shadowTiddlers[title];
+	else
+		return "";
+};
+
+// Retrieve tiddler contents
+//# Supports tiddler slices or sections, encoded in {{{title}}} argument using
+//# the respective separator characters ({{{::}}} or {{{##}}}).
+TiddlyWiki.prototype.getTiddlerText = function(title,defaultText)
+{
+	if(!title)
+		return defaultText;
+	var pos = title.indexOf(config.textPrimitives.sectionSeparator);
+	var section = null;
+	if(pos != -1) {
+		section = title.substr(pos + config.textPrimitives.sectionSeparator.length);
+		title = title.substr(0,pos);
+	}
+	pos = title.indexOf(config.textPrimitives.sliceSeparator);
+	if(pos != -1) {
+		var slice = this.getTiddlerSlice(title.substr(0,pos),title.substr(pos + config.textPrimitives.sliceSeparator.length));
+		if(slice)
+			return slice;
+	}
+	var tiddler = this.fetchTiddler(title);
+	var text = tiddler ? tiddler.text : null;
+	if(!tiddler && this.isShadowTiddler(title)) {
+		text = this.getShadowTiddlerText(title);
+	}
+	if(text) {
+		if(!section)
+			return text;
+		var re = new RegExp("(^!{1,6}[ \t]*" + section.escapeRegExp() + "[ \t]*\n)","mg");
+		re.lastIndex = 0;
+		var match = re.exec(text);
+		if(match) {
+			var t = text.substr(match.index+match[1].length);
+			var re2 = /^!/mg;
+			re2.lastIndex = 0;
+			match = re2.exec(t); //# search for the next heading
+			if(match)
+				t = t.substr(0,match.index-1);//# don't include final \n
+			return t;
+		}
+		return defaultText;
+	}
+	if(defaultText != undefined)
+		return defaultText;
+	return null;
+};
+
+TiddlyWiki.prototype.getRecursiveTiddlerText = function(title,defaultText,depth)
+{
+	var bracketRegExp = new RegExp("(?:\\[\\[([^\\]]+)\\]\\])","mg");
+	var text = this.getTiddlerText(title,null);
+	if(text == null)
+		return defaultText;
+	var textOut = [];
+	var match,lastPos = 0;
+	do {
+		match = bracketRegExp.exec(text);
+		if(match) {
+			textOut.push(text.substr(lastPos,match.index-lastPos));
+			if(match[1]) {
+				if(depth <= 0)
+					textOut.push(match[1]);
+				else
+					textOut.push(this.getRecursiveTiddlerText(match[1],"",depth-1));
+			}
+			lastPos = match.index + match[0].length;
+		} else {
+			textOut.push(text.substr(lastPos));
+		}
+	} while(match);
+	return textOut.join("");
+};
+
+//TiddlyWiki.prototype.slicesRE = /(?:^([\'\/]{0,2})~?([\.\w]+)\:\1[\t\x20]*([^\n]+)[\t\x20]*$)|(?:^\|([\'\/]{0,2})~?([\.\w]+)\:?\4\|[\t\x20]*([^\n]+)[\t\x20]*\|$)/gm;
+TiddlyWiki.prototype.slicesRE = /(?:^([\'\/]{0,2})~?([\.\w]+)\:\1[\t\x20]*([^\n]*)[\t\x20]*$)|(?:^\|([\'\/]{0,2})~?([\.\w]+)\:?\4\|[\t\x20]*([^\|\n]*)[\t\x20]*\|$)/gm;
+// @internal
+TiddlyWiki.prototype.calcAllSlices = function(title)
+{
+	var slices = {};
+	var text = this.getTiddlerText(title,"");
+	this.slicesRE.lastIndex = 0;
+	var m = this.slicesRE.exec(text);
+	while(m) {
+		if(m[2])
+			slices[m[2]] = m[3];
+		else
+			slices[m[5]] = m[6];
+		m = this.slicesRE.exec(text);
+	}
+	return slices;
+};
+
+// Returns the slice of text of the given name
+//#
+//# A text slice is a substring in the tiddler's text that is defined
+//# either like this
+//#    aName:  textSlice
+//# or
+//#    |aName:| textSlice |
+//# or
+//#    |aName| textSlice |
+//#
+//# In the text the name (or name:) may be decorated with '' or //
+//# ie this would also a valid text slice:
+//#
+//#    |''aName:''| textSlice |
+//#
+//# @param name should only contain "word characters" (i.e. "a-ZA-Z_0-9")
+//# @return [may be undefined] the (trimmed) text of the specified slice.
+TiddlyWiki.prototype.getTiddlerSlice = function(title,sliceName)
+{
+	var slices = this.slices[title];
+	if(!slices) {
+		slices = this.calcAllSlices(title);
+		this.slices[title] = slices;
+	}
+	return slices[sliceName];
+};
+
+// Build an hashmap of the specified named slices of a tiddler
+TiddlyWiki.prototype.getTiddlerSlices = function(title,sliceNames)
+{
+	var t,r = {};
+	for(t=0; t<sliceNames.length; t++) {
+		var slice = this.getTiddlerSlice(title,sliceNames[t]);
+		if(slice)
+			r[sliceNames[t]] = slice;
+	}
+	return r;
+};
+
+TiddlyWiki.prototype.suspendNotifications = function()
+{
+	this.notificationLevel--;
+};
+
+TiddlyWiki.prototype.resumeNotifications = function()
+{
+	this.notificationLevel++;
+};
+
+// Invoke the notification handlers for a particular tiddler
+TiddlyWiki.prototype.notify = function(title,doBlanket)
+{
+	if(!this.notificationLevel) {
+	    var t;
+		for(t=0; t<this.namedNotifications.length; t++) {
+			var n = this.namedNotifications[t];
+			if((n.name == null && doBlanket) || (n.name == title))
+				n.notify(title);
+		}
+	}
+};
+
+// Invoke the notification handlers for all tiddlers
+TiddlyWiki.prototype.notifyAll = function()
+{
+	if(!this.notificationLevel) {
+	    var t;
+		for(t=0; t<this.namedNotifications.length; t++) {
+			var n = this.namedNotifications[t];
+			if(n.name)
+				n.notify(n.name);
+		}
+	}
+};
+
+// Add a notification handler to a tiddler
+TiddlyWiki.prototype.addNotification = function(title,fn)
+{
+	var i;
+	for(i=0; i<this.namedNotifications.length; i++) {
+		if((this.namedNotifications[i].name == title) && (this.namedNotifications[i].notify == fn))
+			return this;
+	}
+	this.namedNotifications.push({name: title, notify: fn});
+	return this;
+};
+
+TiddlyWiki.prototype.removeTiddler = function(title)
+{
+	var tiddler = this.fetchTiddler(title);
+	if(tiddler) {
+		this.deleteTiddler(title);
+		this.notify(title,true);
+		this.setDirty(true);
+	}
+};
+
+// Reset the sync status of a freshly synced tiddler
+TiddlyWiki.prototype.resetTiddler = function(title)
+{
+	var tiddler = this.fetchTiddler(title);
+	if(tiddler) {
+		tiddler.clearChangeCount();
+		this.notify(title,true);
+		this.setDirty(true);
+	}
+};
+
+TiddlyWiki.prototype.setTiddlerTag = function(title,status,tag)
+{
+	var tiddler = this.fetchTiddler(title);
+	if(tiddler) {
+		var t = tiddler.tags.indexOf(tag);
+		if(t != -1)
+			tiddler.tags.splice(t,1);
+		if(status)
+			tiddler.tags.push(tag);
+		tiddler.changed();
+		tiddler.incChangeCount();
+		this.notify(title,true);
+		this.setDirty(true);
+	}
+};
+
+TiddlyWiki.prototype.addTiddlerFields = function(title,fields)
+{
+	var tiddler = this.fetchTiddler(title);
+	if(!tiddler)
+		return;
+	merge(tiddler.fields,fields);
+	tiddler.changed();
+	tiddler.incChangeCount();
+	this.notify(title,true);
+	this.setDirty(true);
+};
+
+// Store tiddler in TiddlyWiki instance
+//#
+//# optionally accepts a Tiddler instance as first argument, rendering
+//# subsequent arguments obsolete
+//#
+//# existing tiddlers can be renamed using the newTitle argument
+//#
+//# created and modified arguments are Date objects,
+//# tags argument is an array of strings
+//#
+//# fields should retain existing tiddler's extended fields and use
+//# config.defaultCustomFields as fallback
+//#
+//# NB: Does not trigger autoSaveChanges.
+TiddlyWiki.prototype.saveTiddler = function(title,newTitle,newBody,modifier,modified,tags,fields,clearChangeCount,created,creator)
+{
+	var tiddler;
+	if(title instanceof Tiddler) {
+		tiddler = title;
+		title = tiddler.title;
+		newTitle = title;
+	} else {
+		tiddler = this.fetchTiddler(title);
+		if(tiddler) {
+			created = created || tiddler.created; // Preserve created date
+			creator = creator || tiddler.creator;
+			this.deleteTiddler(title);
+		} else {
+			created = created || modified;
+			tiddler = new Tiddler();
+		}
+		fields = merge(merge({},fields),config.defaultCustomFields,true);
+		tiddler.set(newTitle,newBody,modifier,modified,tags,created,fields,creator);
+	}
+	this.addTiddler(tiddler);
+	if(clearChangeCount)
+		tiddler.clearChangeCount();
+	else
+		tiddler.incChangeCount();
+	if(title != newTitle)
+		this.notify(title,true);
+	this.notify(newTitle,true);
+	if(window.location.protocol == "file:")
+		this.setDirty(true);
+	return tiddler;
+};
+
+TiddlyWiki.prototype.incChangeCount = function(title)
+{
+	var tiddler = this.fetchTiddler(title);
+	if(tiddler)
+		tiddler.incChangeCount();
+};
+
+TiddlyWiki.prototype.getLoader = function()
+{
+	if(!this.loader)
+		this.loader = new TW21Loader();
+	return this.loader;
+};
+
+TiddlyWiki.prototype.getSaver = function()
+{
+	if(!this.saver)
+		this.saver = new TW21Saver();
+	return this.saver;
+};
+
+// Return all tiddlers formatted as an HTML string
+TiddlyWiki.prototype.allTiddlersAsHtml = function()
+{
+	return this.getSaver().externalize(store);
+};
+
+// Load contents of a TiddlyWiki from an HTML DIV
+TiddlyWiki.prototype.loadFromDiv = function(src,idPrefix,noUpdate)
+{
+	this.idPrefix = idPrefix;
+	var storeElem = (typeof src == "string") ? document.getElementById(src) : src;
+	if(!storeElem)
+		return;
+	var tiddlers = this.getLoader().loadTiddlers(this,storeElem.childNodes);
+	this.setDirty(false);
+	if(!noUpdate) {
+		var i;
+		for(i = 0;i<tiddlers.length; i++)
+			tiddlers[i].changed();
+	}
+	jQuery(document).trigger("loadTiddlers");
+};
+
+// Load contents of a TiddlyWiki from a string
+// Returns null if there's an error
+TiddlyWiki.prototype.importTiddlyWiki = function(text)
+{
+	var posDiv = locateStoreArea(text);
+	if(!posDiv)
+		return null;
+	var content = "<" + "html><" + "body>" + text.substring(posDiv[0],posDiv[1] + endSaveArea.length) + "<" + "/body><" + "/html>";
+	// Create the iframe
+	var iframe = document.createElement("iframe");
+	iframe.style.display = "none";
+	document.body.appendChild(iframe);
+	var doc = iframe.document;
+	if(iframe.contentDocument)
+		doc = iframe.contentDocument; // For NS6
+	else if(iframe.contentWindow)
+		doc = iframe.contentWindow.document; // For IE5.5 and IE6
+	// Put the content in the iframe
+	doc.open();
+	doc.writeln(content);
+	doc.close();
+	// Load the content into a TiddlyWiki() object
+	var storeArea = doc.getElementById("storeArea");
+	this.loadFromDiv(storeArea,"store");
+	// Get rid of the iframe
+	iframe.parentNode.removeChild(iframe);
+	return this;
+};
+
+TiddlyWiki.prototype.updateTiddlers = function()
+{
+	this.tiddlersUpdated = true;
+	this.forEachTiddler(function(title,tiddler) {
+		tiddler.changed();
+	});
+};
+
+// Return an array of tiddlers matching a search regular expression
+TiddlyWiki.prototype.search = function(searchRegExp,sortField,excludeTag,match)
+{
+	var candidates = this.reverseLookup("tags",excludeTag,!!match);
+	var t,results = [];
+	for(t=0; t<candidates.length; t++) {
+		if((candidates[t].title.search(searchRegExp) != -1) || (candidates[t].text.search(searchRegExp) != -1))
+			results.push(candidates[t]);
+	}
+	if(!sortField)
+		sortField = "title";
+	results.sort(function(a,b) {return a[sortField] < b[sortField] ? -1 : (a[sortField] == b[sortField] ? 0 : +1);});
+	return results;
+};
+
+// Returns a list of all tags in use
+//   excludeTag - if present, excludes tags that are themselves tagged with excludeTag
+// Returns an array of arrays where [tag][0] is the name of the tag and [tag][1] is the number of occurances
+TiddlyWiki.prototype.getTags = function(excludeTag)
+{
+	var results = [];
+	this.forEachTiddler(function(title,tiddler) {
+	    var g,c;
+		for(g=0; g<tiddler.tags.length; g++) {
+			var tag = tiddler.tags[g];
+			var n = true;
+			for(c=0; c<results.length; c++) {
+				if(results[c][0] == tag) {
+					n = false;
+					results[c][1]++;
+				}
+			}
+			if(n && excludeTag) {
+				var t = this.fetchTiddler(tag);
+				if(t && t.isTagged(excludeTag))
+					n = false;
+			}
+			if(n)
+				results.push([tag,1]);
+		}
+	});
+	results.sort(function(a,b) {return a[0].toLowerCase() < b[0].toLowerCase() ? -1 : (a[0].toLowerCase() == b[0].toLowerCase() ? 0 : +1);});
+	return results;
+};
+
+// Return an array of the tiddlers that are tagged with a given tag
+TiddlyWiki.prototype.getTaggedTiddlers = function(tag,sortField)
+{
+	return this.reverseLookup("tags",tag,true,sortField);
+};
+
+TiddlyWiki.prototype.getValueTiddlers = function(field,value,sortField)
+{
+	return this.reverseLookup(field,value,true,sortField);
+};
+
+// Return an array of the tiddlers that link to a given tiddler
+TiddlyWiki.prototype.getReferringTiddlers = function(title,unusedParameter,sortField)
+{
+	if(!this.tiddlersUpdated)
+		this.updateTiddlers();
+	return this.reverseLookup("links",title,true,sortField);
+};
+
+// Return an array of the tiddlers that do or do not have a specified entry in the specified storage array (ie, "links" or "tags")
+// lookupMatch == true to match tiddlers, false to exclude tiddlers
+TiddlyWiki.prototype.reverseLookup = function(lookupField,lookupValue,lookupMatch,sortField)
+{
+	var results = [];
+	this.forEachTiddler(function(title,tiddler) {
+		var f = !lookupMatch;
+		var values;
+		if(["links", "tags"].contains(lookupField)) {
+			values = tiddler[lookupField];
+		} else {
+			var accessor = TiddlyWiki.standardFieldAccess[lookupField];
+			if(accessor) {
+				values = [ accessor.get(tiddler) ];
+			} else {
+				values = tiddler.fields[lookupField] ? [tiddler.fields[lookupField]] : [];
+			}
+		}
+		var lookup;
+		for(lookup=0; lookup<values.length; lookup++) {
+			if(values[lookup] == lookupValue)
+				f = lookupMatch;
+		}
+		if(f)
+			results.push(tiddler);
+	});
+	if(!sortField)
+		sortField = "title";
+	return this.sortTiddlers(results,sortField);
+};
+
+// Return the tiddlers as a sorted array
+TiddlyWiki.prototype.getTiddlers = function(field,excludeTag)
+{
+	var results = [];
+	this.forEachTiddler(function(title,tiddler) {
+		if(excludeTag == undefined || !tiddler.isTagged(excludeTag))
+			results.push(tiddler);
+	});
+	if(field)
+		results.sort(function(a,b) {return a[field] < b[field] ? -1 : (a[field] == b[field] ? 0 : +1);});
+	return results;
+};
+
+// Return array of names of tiddlers that are referred to but not defined
+TiddlyWiki.prototype.getMissingLinks = function()
+{
+	if(!this.tiddlersUpdated)
+		this.updateTiddlers();
+	var results = [];
+	this.forEachTiddler(function (title,tiddler) {
+		if(tiddler.isTagged("excludeMissing") || tiddler.isTagged("systemConfig"))
+			return;
+		var n;
+		for(n=0; n<tiddler.links.length;n++) {
+			var link = tiddler.links[n];
+			if(this.getTiddlerText(link,null) == null && !this.isShadowTiddler(link) && !config.macros[link])
+				results.pushUnique(link);
+		}
+	});
+	results.sort();
+	return results;
+};
+
+// Return an array of names of tiddlers that are defined but not referred to
+TiddlyWiki.prototype.getOrphans = function()
+{
+	var results = [];
+	this.forEachTiddler(function (title,tiddler) {
+		if(this.getReferringTiddlers(title).length == 0 && !tiddler.isTagged("excludeLists"))
+			results.push(title);
+	});
+	results.sort();
+	return results;
+};
+
+// Return an array of names of all the shadow tiddlers
+TiddlyWiki.prototype.getShadowed = function()
+{
+	var t,results = [];
+	for(t in config.shadowTiddlers) {
+		if(this.isShadowTiddler(t))
+			results.push(t);
+	}
+	results.sort();
+	return results;
+};
+
+// Return an array of tiddlers that have been touched since they were downloaded or created
+TiddlyWiki.prototype.getTouched = function()
+{
+	var results = [];
+	this.forEachTiddler(function(title,tiddler) {
+		if(tiddler.isTouched())
+			results.push(tiddler);
+		});
+	results.sort();
+	return results;
+};
+
+// Resolves a Tiddler reference or tiddler title into a Tiddler object, or null if it doesn't exist
+TiddlyWiki.prototype.resolveTiddler = function(tiddler)
+{
+	var t = (typeof tiddler == "string") ? this.getTiddler(tiddler) : tiddler;
+	return t instanceof Tiddler ? t : null;
+};
+
+// Sort a list of tiddlers
+//# tiddlers - array of Tiddler() objects to be sorted
+//# field - name of field (or extended field) to sort by;
+//#         precede with "+" for ascending sort (the default)
+//#			or "-" for descending sort
+TiddlyWiki.prototype.sortTiddlers = function(tiddlers,field)
+{
+	var asc = +1;
+	switch(field.substr(0,1)) {
+	case "-":
+		asc = -1;
+		field = field.substr(1);
+		break;
+	case "+":
+		field = field.substr(1);
+		break;
+	}
+	if(TiddlyWiki.standardFieldAccess[field]) {
+		if(field=="title") {
+			tiddlers.sort(function(a,b) {return a[field].toLowerCase() < b[field].toLowerCase() ? -asc : (a[field].toLowerCase() == b[field].toLowerCase() ? 0 : asc);});
+		} else {
+			tiddlers.sort(function(a,b) {return a[field] < b[field] ? -asc : (a[field] == b[field] ? 0 : asc);});
+		}
+	} else {
+		tiddlers.sort(function(a,b) {return a.fields[field] < b.fields[field] ? -asc : (a.fields[field] == b.fields[field] ? 0 : +asc);});
+	}
+	return tiddlers;
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Toolbar.js

@@ -0,0 +1,161 @@
+//--
+//-- Tiddler toolbar
+//--
+
+// Create a toolbar command button
+//#  place - parent DOM element
+//#  command - reference to config.commands[] member -or- name of member
+//#  tiddler - reference to tiddler that toolbar applies to
+//#  className - the class to give the button
+config.macros.toolbar.createCommand = function(place,commandName,tiddler,className)
+{
+	if(typeof commandName != "string") {
+		var c = null;
+		var t;
+		for(t in config.commands) {
+			if(config.commands[t] == commandName)
+				c = t;
+		}
+		commandName = c;
+	}
+	if((tiddler instanceof Tiddler) && (typeof commandName == "string")) {
+		var command = config.commands[commandName];
+		if(command.isEnabled ? command.isEnabled(tiddler) : this.isCommandEnabled(command,tiddler)) {
+			var text = command.getText ? command.getText(tiddler) : this.getCommandText(command,tiddler);
+			var tooltip = command.getTooltip ? command.getTooltip(tiddler) : this.getCommandTooltip(command,tiddler);
+			var cmd = command.type == "popup" ? this.onClickPopup : this.onClickCommand;
+			var btn = createTiddlyButton(null,text,tooltip,cmd);
+			btn.setAttribute("commandName",commandName);
+			btn.setAttribute("tiddler",tiddler.title);
+			jQuery(btn).addClass("command_" + commandName);
+			if(className)
+				jQuery(btn).addClass(className);
+			place.appendChild(btn);
+		}
+	}
+};
+
+config.macros.toolbar.isCommandEnabled = function(command,tiddler)
+{
+	var title = tiddler.title;
+	var ro = tiddler.isReadOnly();
+	var shadow = store.isShadowTiddler(title) && !store.tiddlerExists(title);
+	return (!ro || (ro && !command.hideReadOnly)) && !(shadow && command.hideShadow);
+};
+
+config.macros.toolbar.getCommandText = function(command,tiddler)
+{
+	return (tiddler.isReadOnly() && command.readOnlyText) || command.text;
+};
+
+config.macros.toolbar.getCommandTooltip = function(command,tiddler)
+{
+	return (tiddler.isReadOnly() && command.readOnlyTooltip) || command.tooltip;
+};
+
+config.macros.toolbar.onClickCommand = function(ev)
+{
+	var e = ev || window.event;
+	e.cancelBubble = true;
+	if(e.stopPropagation) e.stopPropagation();
+	var command = config.commands[this.getAttribute("commandName")];
+	return command.handler(e,this,this.getAttribute("tiddler"));
+};
+
+config.macros.toolbar.onClickPopup = function(ev)
+{
+	var e = ev || window.event;
+	e.cancelBubble = true;
+	if(e.stopPropagation) e.stopPropagation();
+	var popup = Popup.create(this);
+	var command = config.commands[this.getAttribute("commandName")];
+	var title = this.getAttribute("tiddler");
+	popup.setAttribute("tiddler",title);
+	command.handlePopup(popup,title);
+	Popup.show();
+	return false;
+};
+
+// Invoke the first command encountered from a given place that is tagged with a specified class
+config.macros.toolbar.invokeCommand = function(place,className,event)
+{
+	var children = place.getElementsByTagName("a");
+	var t;
+	for(t=0; t<children.length; t++) {
+		var c = children[t];
+		if(jQuery(c).hasClass(className) && c.getAttribute && c.getAttribute("commandName")) {
+			if(c.onclick instanceof Function)
+				c.onclick.call(c,event);
+			break;
+		}
+	}
+};
+
+config.macros.toolbar.onClickMore = function(ev)
+{
+	var e = this.nextSibling;
+	e.style.display = "inline";
+	this.style.display = "none";
+	return false;
+};
+
+config.macros.toolbar.onClickLess = function(ev)
+{
+	var e = this.parentNode;
+	var m = e.previousSibling;
+	e.style.display = "none";
+	m.style.display = "inline";
+	return false;
+};
+
+config.macros.toolbar.handler = function(place,macroName,params,wikifier,paramString,tiddler)
+{
+	var t;
+	for(t=0; t<params.length; t++) {
+		var btn;
+		var c = params[t];
+		switch(c) {
+		case "!":
+			createTiddlyText(place,this.separator);
+			break;
+		case "*":
+			createTiddlyElement(place,"br");
+			break;
+		case "<":
+			btn = createTiddlyButton(place,this.lessLabel,this.lessPrompt,config.macros.toolbar.onClickLess);
+			jQuery(btn).addClass("lessCommand");
+			break;
+		case ">":
+			btn = createTiddlyButton(place,this.moreLabel,this.morePrompt,config.macros.toolbar.onClickMore);
+			jQuery(btn).addClass("moreCommand");
+			var e = createTiddlyElement(place,"span",null,"moreCommand");
+			e.style.display = "none";
+			place = e;
+			break;
+		default:
+			var className = "";
+			switch(c.substr(0,1)) {
+			case "+":
+				className = "defaultCommand";
+				c = c.substr(1);
+				break;
+			case "-":
+				className = "cancelCommand";
+				c = c.substr(1);
+				break;
+			}
+			if(config.commands[c]) {
+				this.createCommand(place,c,tiddler,className);
+			} else {
+				this.customCommand(place,c,wikifier,tiddler);
+			}
+			break;
+		}
+	}
+};
+
+// Overrideable function to extend toolbar handler
+config.macros.toolbar.customCommand = function(place,command,wikifier,tiddler)
+{
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Upgrade.js

@@ -0,0 +1,117 @@
+//--
+//-- Upgrade macro
+//--
+
+config.macros.upgrade.handler = function(place)
+{
+	var w = new Wizard();
+	w.createWizard(place,this.wizardTitle);
+	w.addStep(this.step1Title,this.step1Html.format([this.source,this.source]));
+	w.setButtons([{caption: this.upgradeLabel, tooltip: this.upgradePrompt, onClick: this.onClickUpgrade}]);
+};
+
+config.macros.upgrade.onClickUpgrade = function(e)
+{
+	var me = config.macros.upgrade;
+	var w = new Wizard(this);
+	if(window.location.protocol != "file:") {
+		alert(me.errorCantUpgrade);
+		return false;
+	}
+	if(story.areAnyDirty() || store.isDirty()) {
+		alert(me.errorNotSaved);
+		return false;
+	}
+	var localPath = getLocalPath(document.location.toString());
+	var backupPath = getBackupPath(localPath,me.backupExtension);
+	w.setValue("backupPath",backupPath);
+	w.setButtons([],me.statusPreparingBackup);
+	var original = loadOriginal(localPath);
+	w.setButtons([],me.statusSavingBackup);
+	var backup = copyFile(backupPath,localPath);
+	if(!backup)
+		backup = saveFile(backupPath,original);
+	if(!backup) {
+		w.setButtons([],me.errorSavingBackup);
+		alert(me.errorSavingBackup);
+		return false;
+	}
+	w.setButtons([],me.statusLoadingCore);
+	var options = {
+		type:"GET",
+		url:me.source,
+		processData:false,
+		success:function(data,textStatus,jqXHR) {
+			me.onLoadCore(true,w,jqXHR.responseText,me.source,jqXHR);
+		},
+		error:function(jqXHR,textStatus,errorThrown) {
+			me.onLoadCore(false,w,null,me.source,jqXHR);
+		}
+	};
+	ajaxReq(options);
+	return false;
+};
+
+config.macros.upgrade.onLoadCore = function(status,params,responseText,url,xhr)
+{
+	var me = config.macros.upgrade;
+	var w = params;
+	var errMsg;
+	if(!status)
+		errMsg = me.errorLoadingCore;
+	var newVer = me.extractVersion(responseText);
+	if(!newVer)
+		errMsg = me.errorCoreFormat;
+	if(errMsg) {
+		w.setButtons([],errMsg);
+		alert(errMsg);
+		return;
+	}
+	var onStartUpgrade = function(e) {
+		w.setButtons([],me.statusSavingCore);
+		var localPath = getLocalPath(document.location.toString());
+		saveFile(localPath,responseText);
+		w.setButtons([],me.statusReloadingCore);
+		var backupPath = w.getValue("backupPath");
+		var newLoc = document.location.toString() + "?time=" + new Date().convertToYYYYMMDDHHMM() + "#upgrade:[[" + encodeURI(backupPath) + "]]";
+		window.setTimeout(function () {window.location = newLoc;},10);
+	};
+	var step2 = [me.step2Html_downgrade,me.step2Html_restore,me.step2Html_upgrade][compareVersions(version,newVer) + 1];
+	w.addStep(me.step2Title,step2.format([formatVersion(newVer),formatVersion(version)]));
+	w.setButtons([{caption: me.startLabel, tooltip: me.startPrompt, onClick: onStartUpgrade},{caption: me.cancelLabel, tooltip: me.cancelPrompt, onClick: me.onCancel}]);
+};
+
+config.macros.upgrade.onCancel = function(e)
+{
+	var me = config.macros.upgrade;
+	var w = new Wizard(this);
+	w.addStep(me.step3Title,me.step3Html);
+	w.setButtons([]);
+	return false;
+};
+
+config.macros.upgrade.extractVersion = function(upgradeFile)
+{
+	var re = /^var version = \{title: "([^"]+)", major: (\d+), minor: (\d+), revision: (\d+)(, beta: (\d+)){0,1}, date: new Date\("([^"]+)"\)/mg;
+	var m = re.exec(upgradeFile);
+	return m ? {title: m[1], major: m[2], minor: m[3], revision: m[4], beta: m[6], date: new Date(m[7])} : null;
+};
+
+function upgradeFrom(path)
+{
+	var importStore = new TiddlyWiki();
+	var tw = loadFile(path);
+	if(window.netscape !== undefined)
+		tw = convertUTF8ToUnicode(tw);
+	importStore.importTiddlyWiki(tw);
+	importStore.forEachTiddler(function(title,tiddler) {
+		if(!store.getTiddler(title)) {
+			store.addTiddler(tiddler);
+		}
+	});
+	refreshDisplay();
+	saveChanges(); //# To create appropriate Markup* sections
+	alert(config.messages.upgradeDone.format([formatVersion()]));
+	window.location = window.location.toString().substr(0,window.location.toString().lastIndexOf("?"));
+}
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Utilities.js

@@ -0,0 +1,285 @@
+//--
+//-- TiddlyWiki-specific utility functions
+//--
+
+// Returns TiddlyWiki version string
+function formatVersion(v)
+{
+	v = v || version;
+	return v.major + "." + v.minor + "." + v.revision +
+		(v.alpha ? " (alpha " + v.alpha + ")" : "") +
+		(v.beta ? " (beta " + v.beta + ")" : "");
+}
+
+//# Compares two TiddlyWiki version objects
+//# Returns +1 if v2 is later than v1
+//#          0 if v2 is the same as v1
+//#         -1 if v2 is earlier than v1
+//# version without a beta number is later than a version with a beta number
+function compareVersions(v1,v2)
+{
+	var x1,x2,i,a = ["major","minor","revision"];
+	for(i = 0; i<a.length; i++) {
+		x1 = v1[a[i]] || 0;
+		x2 = v2[a[i]] || 0;
+		if(x1<x2)
+			return 1;
+		if(x1>x2)
+			return -1;
+	}
+	x1 = v1.beta || 9999;
+	x2 = v2.beta || 9999;
+	if(x1<x2)
+		return 1;
+	return x1 > x2 ? -1 : 0;
+}
+
+function merge(dst,src,preserveExisting)
+{
+	var i;
+	for(i in src) {
+		if(!preserveExisting || dst[i] === undefined)
+			dst[i] = src[i];
+	}
+	return dst;
+}
+
+// Resolve the target object of an event
+function resolveTarget(e)
+{
+	var obj;
+	if(e.target)
+		obj = e.target;
+	else if(e.srcElement)
+		obj = e.srcElement;
+	if(obj.nodeType == 3) // defeat Safari bug
+		obj = obj.parentNode;
+	return obj;
+}
+
+// Returns a string containing the description of an exception, optionally prepended by a message
+function exceptionText(e,message)
+{
+	var s = e.description || e.toString();
+	return message ? "%0:\n%1".format([message,s]) : s;
+}
+
+// Displays an alert of an exception description with optional message
+function showException(e,message)
+{
+	alert(exceptionText(e,message));
+}
+
+function alertAndThrow(m)
+{
+	alert(m);
+	throw(m);
+}
+
+function glyph(name)
+{
+	var g = config.glyphs;
+	var b = g.currBrowser;
+	if(b == null) {
+		b = 0;
+		while(b < g.browsers.length-1 && !g.browsers[b]())
+			b++;
+		g.currBrowser = b;
+	}
+	if(!g.codes[name])
+		return "";
+	return g.codes[name][b];
+}
+
+function createTiddlyText(parent,text)
+{
+	return parent.appendChild(document.createTextNode(text));
+}
+
+function createTiddlyCheckbox(parent,caption,checked,onChange)
+{
+	var cb = document.createElement("input");
+	cb.setAttribute("type","checkbox");
+	cb.onclick = onChange;
+	parent.appendChild(cb);
+	cb.checked = checked;
+	cb.className = "chkOptionInput";
+	if(caption)
+		wikify(caption,parent);
+	return cb;
+}
+
+function createTiddlyElement(parent,element,id,className,text,attribs)
+{
+	var n,e = document.createElement(element);
+	if(className != null)
+		e.className = className;
+	if(id != null)
+		e.setAttribute("id",id);
+	if(text != null)
+		e.appendChild(document.createTextNode(text));
+	if(attribs) {
+		for(n in attribs) {
+			e.setAttribute(n,attribs[n]);
+		}
+	}
+	if(parent != null)
+		parent.appendChild(e);
+	return e;
+}
+
+function createTiddlyButton(parent,text,tooltip,action,className,id,accessKey,attribs)
+{
+	var i,btn = document.createElement("a");
+	btn.setAttribute("href","javascript:;");
+	if(action) {
+		btn.onclick = action;
+	}
+	if(tooltip)
+		btn.setAttribute("title",tooltip);
+	if(text)
+		btn.appendChild(document.createTextNode(text));
+	btn.className = className || "button";
+	if(id)
+		btn.id = id;
+	if(attribs) {
+		for(i in attribs) {
+			btn.setAttribute(i,attribs[i]);
+		}
+	}
+	if(parent)
+		parent.appendChild(btn);
+	if(accessKey)
+		btn.setAttribute("accessKey",accessKey);
+	return btn;
+}
+
+//# Create a link to an external resource
+//#   place - element where the link should be created
+//#   url - link target
+//#   label - link text (optional)
+function createExternalLink(place,url,label)
+{
+	var link = document.createElement("a");
+	link.className = "externalLink";
+	link.href = url;
+	var f = config.messages.externalLinkTooltip;
+	link.title = f ? f.format([url]) : url;
+	if(config.options.chkOpenInNewWindow)
+		link.target = "_blank";
+	place.appendChild(link);
+	if(label)
+		createTiddlyText(link, label);
+	return link;
+}
+
+function getTiddlyLinkInfo(title,currClasses)
+{
+	var classes = currClasses ? currClasses.split(" ") : [];
+	classes.pushUnique("tiddlyLink");
+	var tiddler = store.fetchTiddler(title);
+	var subTitle;
+	if(tiddler) {
+		subTitle = tiddler.getSubtitle();
+		classes.pushUnique("tiddlyLinkExisting");
+		classes.remove("tiddlyLinkNonExisting");
+		classes.remove("shadow");
+	} else {
+	    var f;
+		classes.remove("tiddlyLinkExisting");
+		classes.pushUnique("tiddlyLinkNonExisting");
+		if(store.isShadowTiddler(title)) {
+			f = config.messages.shadowedTiddlerToolTip;
+			classes.pushUnique("shadow");
+		} else {
+			f = config.messages.undefinedTiddlerToolTip;
+			classes.remove("shadow");
+		}
+		subTitle = f ? f.format([title]) : "";
+	}
+	if(typeof config.annotations[title]=="string")
+		subTitle = config.annotations[title];
+	return {classes: classes.join(" "),subTitle: subTitle};
+}
+
+// Event handler for clicking on a tiddly link
+function onClickTiddlerLink(ev)
+{
+	var e = ev || window.event;
+	var target = resolveTarget(e);
+	var link = target;
+	var title = null;
+	var fields = null;
+	var noToggle = null;
+	do {
+		title = link.getAttribute("tiddlyLink");
+		fields = link.getAttribute("tiddlyFields");
+		noToggle = link.getAttribute("noToggle");
+		link = link.parentNode;
+	} while(title == null && link != null);
+	if(!store.isShadowTiddler(title)) {
+		var f = fields ? fields.decodeHashMap() : {};
+		fields = String.encodeHashMap(merge(f,config.defaultCustomFields,true));
+	}
+	if(title) {
+		var toggling = e.metaKey || e.ctrlKey;
+		if(config.options.chkToggleLinks)
+			toggling = !toggling;
+		if(noToggle)
+			toggling = false;
+		if(store.getTiddler(title))
+			fields = null;
+		story.displayTiddler(target,title,null,true,null,fields,toggling);
+	}
+	clearMessage();
+	return false;
+}
+
+//# Create a link to a particular tiddler
+//#   place - element where the link should be created
+//#   title - title of target tiddler
+//#   includeText - flag for whether to include the title as the text of the link
+//#   className - custom CSS class for the link
+//#   linkedFromTiddler - tiddler from which to inherit extended fields
+//#   noToggle - flag to force the link to open the target, even if chkToggleLinks is on
+function createTiddlyLink(place,title,includeText,className,isStatic,linkedFromTiddler,noToggle)
+{
+	var title = jQuery.trim(title);
+	var text = includeText ? title : null;
+	var i = getTiddlyLinkInfo(title,className);
+	var btn = isStatic ? createExternalLink(place,store.getTiddlerText("SiteUrl",null) + "#" + title) : createTiddlyButton(place,text,i.subTitle,onClickTiddlerLink,i.classes);
+	if(isStatic)
+		btn.className += ' ' + className;
+	btn.setAttribute("refresh","link");
+	btn.setAttribute("tiddlyLink",title);
+	if(noToggle)
+		btn.setAttribute("noToggle","true");
+	if(linkedFromTiddler) {
+		var fields = linkedFromTiddler.getInheritedFields();
+		if(fields)
+			btn.setAttribute("tiddlyFields",fields);
+	}
+	return btn;
+}
+
+function refreshTiddlyLink(e,title)
+{
+	var i = getTiddlyLinkInfo(title,e.className);
+	e.className = i.classes;
+	e.title = i.subTitle;
+}
+
+function createTiddlyDropDown(place,onchange,options,defaultValue)
+{
+	var sel = createTiddlyElement(place,"select");
+	sel.onchange = onchange;
+	var t;
+	for(t=0; t<options.length; t++) {
+		var e = createTiddlyElement(sel,"option",null,null,options[t].caption);
+		e.value = options[t].name;
+		if(options[t].name == defaultValue)
+			e.selected = true;
+	}
+	return sel;
+}
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/UtilitiesPopup.js

@@ -0,0 +1,113 @@
+//--
+//-- TiddlyWiki-specific popup utility functions
+//--
+
+// Event handler for 'open all' on a tiddler popup
+function onClickTagOpenAll(ev)
+{
+	var tiddlers = store.getTaggedTiddlers(this.getAttribute("tag"));
+	var sortby = this.getAttribute("sortby");
+	if(sortby&&sortby.length) {
+		store.sortTiddlers(tiddlers,sortby);
+	}
+	story.displayTiddlers(this,tiddlers);
+	return false;
+}
+
+// Event handler for clicking on a tiddler tag
+function onClickTag(ev)
+{
+	var e = ev || window.event;
+	var popup = Popup.create(this);
+	jQuery(popup).addClass("taggedTiddlerList");
+	var tag = this.getAttribute("tag");
+	var title = this.getAttribute("tiddler");
+	if(popup && tag) {
+		var tagged = tag.indexOf("[")==-1 ? store.getTaggedTiddlers(tag) : store.filterTiddlers(tag);
+		var sortby = this.getAttribute("sortby");
+		if(sortby&&sortby.length) {
+			store.sortTiddlers(tagged,sortby);
+		}
+		var titles = [];
+		var r;
+		for(r=0;r<tagged.length;r++) {
+			if(tagged[r].title != title)
+				titles.push(tagged[r].title);
+		}
+		var lingo = config.views.wikified.tag;
+		if(titles.length > 0) {
+			var openAll = createTiddlyButton(createTiddlyElement(popup,"li"),lingo.openAllText.format([tag]),lingo.openAllTooltip,onClickTagOpenAll);
+			openAll.setAttribute("tag",tag);
+			openAll.setAttribute("sortby",sortby);
+			createTiddlyElement(createTiddlyElement(popup,"li",null,"listBreak"),"div");
+			for(r=0; r<titles.length; r++) {
+				createTiddlyLink(createTiddlyElement(popup,"li"),titles[r],true);
+			}
+		} else {
+			createTiddlyElement(popup,"li",null,"disabled",lingo.popupNone.format([tag]));
+		}
+		createTiddlyElement(createTiddlyElement(popup,"li",null,"listBreak"),"div");
+		var h = createTiddlyLink(createTiddlyElement(popup,"li"),tag,false);
+		createTiddlyText(h,lingo.openTag.format([tag]));
+	}
+	Popup.show();
+	e.cancelBubble = true;
+	if(e.stopPropagation) e.stopPropagation();
+	return false;
+}
+
+// Create a button for a tag with a popup listing all the tiddlers that it tags
+//# title and tooltip arguments are optional
+function createTagButton(place,tag,excludeTiddler,title,tooltip)
+{
+	var btn = createTiddlyButton(place,title||tag,(tooltip||config.views.wikified.tag.tooltip).format([tag]),onClickTag);
+	btn.setAttribute("tag",tag);
+	if(excludeTiddler)
+		btn.setAttribute("tiddler",excludeTiddler);
+	return btn;
+}
+
+function onClickTiddlyPopup(ev)
+{
+	var e = ev || window.event;
+	var tiddler = this.tiddler;
+	if(tiddler.text) {
+		var popup = Popup.create(this,"div","popupTiddler");
+		wikify(tiddler.text,popup,null,tiddler);
+		Popup.show();
+	}
+	if(e) e.cancelBubble = true;
+	if(e && e.stopPropagation) e.stopPropagation();
+	return false;
+}
+
+function createTiddlyPopup(place,caption,tooltip,tiddler)
+{
+	if(tiddler.text) {
+		createTiddlyLink(place,caption,true);
+		var btn = createTiddlyButton(place,glyph("downArrow"),tooltip,onClickTiddlyPopup,"tiddlerPopupButton");
+		btn.tiddler = tiddler;
+	} else {
+		createTiddlyText(place,caption);
+	}
+}
+
+function onClickError(ev)
+{
+	var e = ev || window.event;
+	var popup = Popup.create(this);
+	var lines = this.getAttribute("errorText").split("\n");
+	var t;
+	for(t=0; t<lines.length; t++)
+		createTiddlyElement(popup,"li",null,null,lines[t]);
+	Popup.show();
+	e.cancelBubble = true;
+	if(e.stopPropagation) e.stopPropagation();
+	return false;
+}
+
+function createTiddlyError(place,title,text)
+{
+	var btn = createTiddlyButton(place,title,null,onClickError,"errorButton");
+	if(text) btn.setAttribute("errorText",text);
+}

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Version.js

@@ -0,0 +1 @@
+var version = {title: "TiddlyWiki", major: 2, minor: 6, revision: 5, date: new Date("October 6, 2011"), extensions: {}};

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Wikifier.js

@@ -0,0 +1,237 @@
+//--
+//-- Wikifier
+//--
+
+function getParser(tiddler,format)
+{
+	if(tiddler) {
+		if(!format)
+			format = tiddler.fields["wikiformat"];
+		var i;
+		if(format) {
+			//# format field takes precedence over format tag
+			for(i in config.parsers) {
+				if(format == config.parsers[i].format)
+					return config.parsers[i];
+			}
+		} else {
+			for(i in config.parsers) {
+				if(tiddler.isTagged(config.parsers[i].formatTag))
+					return config.parsers[i];
+			}
+		}
+	}
+	return formatter;
+}
+
+//# Construct a wikifier object
+//# source - source string that's going to be wikified
+//# formatter - Formatter() object containing the list of formatters to be used
+//# highlightRegExp - regular expression of the text string to highlight
+//# tiddler - reference to the tiddler that's taken to be the container for this wikification
+function Wikifier(source,formatter,highlightRegExp,tiddler)
+{
+	this.source = source;
+	this.output = null;
+	this.formatter = formatter;
+	this.nextMatch = 0;
+	this.autoLinkWikiWords = tiddler && tiddler.autoLinkWikiWords() == false ? false : true;
+	this.highlightRegExp = highlightRegExp;
+	this.highlightMatch = null;
+	this.isStatic = false;
+	if(highlightRegExp) {
+		highlightRegExp.lastIndex = 0;
+		this.highlightMatch = highlightRegExp.exec(source);
+	}
+	this.tiddler = tiddler;
+}
+
+Wikifier.prototype.wikifyPlain = function()
+{
+	var e = createTiddlyElement(document.body,"div");
+	e.style.display = "none";
+	this.subWikify(e);
+	var text = jQuery(e).text();
+	jQuery(e).remove();
+	return text;
+};
+
+Wikifier.prototype.subWikify = function(output,terminator)
+{
+	//# Handle the terminated and unterminated cases separately, this speeds up wikifikation by about 30%
+	try {
+		if(terminator)
+			this.subWikifyTerm(output,new RegExp("(" + terminator + ")","mg"));
+		else
+			this.subWikifyUnterm(output);
+	} catch(ex) {
+		showException(ex);
+	}
+};
+
+Wikifier.prototype.subWikifyUnterm = function(output)
+{
+	//# subWikify can be indirectly recursive, so we need to save the old output pointer
+	var oldOutput = this.output;
+	this.output = output;
+	//# Get the first match
+	this.formatter.formatterRegExp.lastIndex = this.nextMatch;
+	var formatterMatch = this.formatter.formatterRegExp.exec(this.source);
+	while(formatterMatch) {
+		// Output any text before the match
+		if(formatterMatch.index > this.nextMatch)
+			this.outputText(this.output,this.nextMatch,formatterMatch.index);
+		// Set the match parameters for the handler
+		this.matchStart = formatterMatch.index;
+		this.matchLength = formatterMatch[0].length;
+		this.matchText = formatterMatch[0];
+		this.nextMatch = this.formatter.formatterRegExp.lastIndex;
+		//# Figure out which formatter matched and call its handler
+		var t;
+		for(t=1; t<formatterMatch.length; t++) {
+			if(formatterMatch[t]) {
+				this.formatter.formatters[t-1].handler(this);
+				this.formatter.formatterRegExp.lastIndex = this.nextMatch;
+				break;
+			}
+		}
+		//# Get the next match
+		formatterMatch = this.formatter.formatterRegExp.exec(this.source);
+	}
+	//# Output any text after the last match
+	if(this.nextMatch < this.source.length) {
+		this.outputText(this.output,this.nextMatch,this.source.length);
+		this.nextMatch = this.source.length;
+	}
+	//# Restore the output pointer
+	this.output = oldOutput;
+};
+
+Wikifier.prototype.subWikifyTerm = function(output,terminatorRegExp)
+{
+	//# subWikify can be indirectly recursive, so we need to save the old output pointer
+	var oldOutput = this.output;
+	this.output = output;
+	//# Get the first matches for the formatter and terminator RegExps
+	terminatorRegExp.lastIndex = this.nextMatch;
+	var terminatorMatch = terminatorRegExp.exec(this.source);
+	this.formatter.formatterRegExp.lastIndex = this.nextMatch;
+	var formatterMatch = this.formatter.formatterRegExp.exec(terminatorMatch ? this.source.substr(0,terminatorMatch.index) : this.source);
+	while(terminatorMatch || formatterMatch) {
+		//# Check for a terminator match before the next formatter match
+		if(terminatorMatch && (!formatterMatch || terminatorMatch.index <= formatterMatch.index)) {
+			//# Output any text before the match
+			if(terminatorMatch.index > this.nextMatch)
+				this.outputText(this.output,this.nextMatch,terminatorMatch.index);
+			//# Set the match parameters
+			this.matchText = terminatorMatch[1];
+			this.matchLength = terminatorMatch[1].length;
+			this.matchStart = terminatorMatch.index;
+			this.nextMatch = this.matchStart + this.matchLength;
+			//# Restore the output pointer
+			this.output = oldOutput;
+			return;
+		}
+		//# It must be a formatter match; output any text before the match
+		if(formatterMatch.index > this.nextMatch)
+			this.outputText(this.output,this.nextMatch,formatterMatch.index);
+		//# Set the match parameters
+		this.matchStart = formatterMatch.index;
+		this.matchLength = formatterMatch[0].length;
+		this.matchText = formatterMatch[0];
+		this.nextMatch = this.formatter.formatterRegExp.lastIndex;
+		//# Figure out which formatter matched and call its handler
+		var t;
+		for(t=1; t<formatterMatch.length; t++) {
+			if(formatterMatch[t]) {
+				this.formatter.formatters[t-1].handler(this);
+				this.formatter.formatterRegExp.lastIndex = this.nextMatch;
+				break;
+			}
+		}
+		//# Get the next match
+		terminatorRegExp.lastIndex = this.nextMatch;
+		terminatorMatch = terminatorRegExp.exec(this.source);
+		formatterMatch = this.formatter.formatterRegExp.exec(terminatorMatch ? this.source.substr(0,terminatorMatch.index) : this.source);
+	}
+	//# Output any text after the last match
+	if(this.nextMatch < this.source.length) {
+		this.outputText(this.output,this.nextMatch,this.source.length);
+		this.nextMatch = this.source.length;
+	}
+	//# Restore the output pointer
+	this.output = oldOutput;
+};
+
+Wikifier.prototype.outputText = function(place,startPos,endPos)
+{
+	//# Check for highlights
+	while(this.highlightMatch && (this.highlightRegExp.lastIndex > startPos) && (this.highlightMatch.index < endPos) && (startPos < endPos)) {
+		//# Deal with any plain text before the highlight
+		if(this.highlightMatch.index > startPos) {
+			createTiddlyText(place,this.source.substring(startPos,this.highlightMatch.index));
+			startPos = this.highlightMatch.index;
+		}
+		//# Deal with the highlight
+		var highlightEnd = Math.min(this.highlightRegExp.lastIndex,endPos);
+		createTiddlyElement(place,"span",null,"highlight",this.source.substring(startPos,highlightEnd));
+		startPos = highlightEnd;
+		//# Nudge along to the next highlight if we're done with this one
+		if(startPos >= this.highlightRegExp.lastIndex)
+			this.highlightMatch = this.highlightRegExp.exec(this.source);
+	}
+	//# Do the unhighlighted text left over
+	if(startPos < endPos) {
+		createTiddlyText(place,this.source.substring(startPos,endPos));
+	}
+};
+
+function wikify(source,output,highlightRegExp,tiddler)
+{
+	if(source) {
+		var wikifier = new Wikifier(source,getParser(tiddler),highlightRegExp,tiddler);
+		var t0 = new Date();
+		wikifier.subWikify(output);
+		if(tiddler && config.options.chkDisplayInstrumentation)
+			displayMessage("wikify:" +tiddler.title+ " in " + (new Date()-t0) + " ms");
+	}
+}
+
+function wikifyStatic(source,highlightRegExp,tiddler,format)
+{
+	var e = createTiddlyElement(document.body,"pre");
+	e.style.display = "none";
+	var html = "";
+	if(source && source != "") {
+		if(!tiddler)
+			tiddler = new Tiddler("temp");
+		var wikifier = new Wikifier(source,getParser(tiddler,format),highlightRegExp,tiddler);
+		wikifier.isStatic = true;
+		wikifier.subWikify(e);
+		html = e.innerHTML;
+		jQuery(e).remove();
+	}
+	return html;
+}
+
+//# Wikify a string to plain text
+//#   text - text to wikify
+//#   limit - maximum number of characters to generate
+//#   tiddler - optional reference to the tiddler containing this text
+function wikifyPlainText(text,limit,tiddler)
+{
+	if(limit > 0)
+		text = text.substr(0,limit);
+	var wikifier = new Wikifier(text,formatter,null,tiddler);
+	return wikifier.wikifyPlain();
+}
+
+//# Highlight plain text into an element
+function highlightify(source,output,highlightRegExp,tiddler)
+{
+	if(source) {
+		var wikifier = new Wikifier(source,formatter,highlightRegExp,tiddler);
+		wikifier.outputText(output,0,source.length);
+	}
+}
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Wizard.js

@@ -0,0 +1,69 @@
+//--
+//-- Wizard support
+//--
+
+function Wizard(elem)
+{
+	if(elem) {
+		this.formElem = findRelated(elem,"wizard","className");
+		this.bodyElem = findRelated(this.formElem.firstChild,"wizardBody","className","nextSibling");
+		this.footElem = findRelated(this.formElem.firstChild,"wizardFooter","className","nextSibling");
+	} else {
+		this.formElem = null;
+		this.bodyElem = null;
+		this.footElem = null;
+	}
+}
+
+Wizard.prototype.setValue = function(name,value)
+{
+	jQuery(this.formElem).data(name, value);
+};
+
+Wizard.prototype.getValue = function(name)
+{
+	return this.formElem ? jQuery(this.formElem).data(name) : null;
+};
+
+Wizard.prototype.createWizard = function(place,title)
+{
+	this.formElem = createTiddlyElement(place,"form",null,"wizard");
+	createTiddlyElement(this.formElem,"h1",null,null,title);
+	this.bodyElem = createTiddlyElement(this.formElem,"div",null,"wizardBody");
+	this.footElem = createTiddlyElement(this.formElem,"div",null,"wizardFooter");
+	return this.formElem;
+};
+
+Wizard.prototype.clear = function()
+{
+	jQuery(this.bodyElem).empty();
+};
+
+Wizard.prototype.setButtons = function(buttonInfo,status)
+{
+	jQuery(this.footElem).empty();
+	var t;
+	for(t=0; t<buttonInfo.length; t++) {
+		createTiddlyButton(this.footElem,buttonInfo[t].caption,buttonInfo[t].tooltip,buttonInfo[t].onClick);
+		insertSpacer(this.footElem);
+		}
+	if(typeof status == "string") {
+		createTiddlyElement(this.footElem,"span",null,"status",status);
+	}
+};
+
+Wizard.prototype.addStep = function(stepTitle,html)
+{
+	jQuery(this.bodyElem).empty();
+	var w = createTiddlyElement(this.bodyElem,"div");
+	createTiddlyElement(w,"h2",null,null,stepTitle);
+	var step = createTiddlyElement(w,"div",null,"wizardStep");
+	step.innerHTML = html;
+	applyHtmlMacros(step,tiddler);
+};
+
+Wizard.prototype.getElement = function(name)
+{
+	return this.formElem.elements[name];
+};
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/Zoomer.js

@@ -0,0 +1,21 @@
+//--
+//-- Zoomer animation
+//--
+
+function Zoomer(text,startElement,targetElement,unused)
+{
+	var e = createTiddlyElement(document.body,"div",null,"zoomer");
+	createTiddlyElement(e,"div",null,null,text);
+	var winWidth = findWindowWidth();
+	var winHeight = findWindowHeight();
+	var p = [
+		{style: 'left', start: findPosX(startElement), end: findPosX(targetElement), template: '%0px'},
+		{style: 'top', start: findPosY(startElement), end: findPosY(targetElement), template: '%0px'},
+		{style: 'width', start: Math.min(startElement.scrollWidth,winWidth), end: Math.min(targetElement.scrollWidth,winWidth), template: '%0px', atEnd: 'auto'},
+		{style: 'height', start: Math.min(startElement.scrollHeight,winHeight), end: Math.min(targetElement.scrollHeight,winHeight), template: '%0px', atEnd: 'auto'},
+		{style: 'fontSize', start: 8, end: 24, template: '%0pt'}
+	];
+	var c = function(element,properties) {jQuery(element).remove();};
+	return new Morpher(e,config.animDuration,p,c);
+}
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/main.js

@@ -0,0 +1,236 @@
+//--
+//-- Main
+//--
+
+var params = null; // Command line parameters
+var store = null; // TiddlyWiki storage
+var story = null; // Main story
+var formatter = null; // Default formatters for the wikifier
+var anim = typeof Animator == "function" ? new Animator() : null; // Animation engine
+var readOnly = false; // Whether we're in readonly mode
+var highlightHack = null; // Embarrassing hack department...
+var hadConfirmExit = false; // Don't warn more than once
+var safeMode = false; // Disable all plugins and cookies
+var showBackstage; // Whether to include the backstage area
+var installedPlugins = []; // Information filled in when plugins are executed
+var startingUp = false; // Whether we're in the process of starting up
+var pluginInfo,tiddler; // Used to pass information to plugins in loadPlugins()
+
+// Whether to use the JavaSaver applet
+var useJavaSaver = (config.browser.isSafari || config.browser.isOpera) && (document.location.toString().substr(0,4) != "http");
+
+if(!window || !window.console) {
+	console = {tiddlywiki:true,log:function(message) {displayMessage(message);}};
+}
+
+// Starting up
+function main()
+{
+	var t10,t9,t8,t7,t6,t5,t4,t3,t2,t1,t0 = new Date();
+	startingUp = true;
+	var doc = jQuery(document);
+	jQuery.noConflict();
+	window.onbeforeunload = function(e) {if(window.confirmExit) return confirmExit();};
+	params = getParameters();
+	if(params)
+		params = params.parseParams("open",null,false);
+	store = new TiddlyWiki({config:config});
+	invokeParamifier(params,"oninit");
+	story = new Story("tiddlerDisplay","tiddler");
+	addEvent(document,"click",Popup.onDocumentClick);
+	saveTest();
+	var s;
+	for(s=0; s<config.notifyTiddlers.length; s++)
+		store.addNotification(config.notifyTiddlers[s].name,config.notifyTiddlers[s].notify);
+	t1 = new Date();
+	loadShadowTiddlers();
+	doc.trigger("loadShadows");
+	t2 = new Date();
+	store.loadFromDiv("storeArea","store",true);
+	doc.trigger("loadTiddlers");
+	loadOptions();
+	t3 = new Date();
+	invokeParamifier(params,"onload");
+	t4 = new Date();
+	readOnly = (window.location.protocol == "file:") ? false : config.options.chkHttpReadOnly;
+	var pluginProblem = loadPlugins("systemConfig");
+	doc.trigger("loadPlugins");
+	t5 = new Date();
+	formatter = new Formatter(config.formatters);
+	invokeParamifier(params,"onconfig");
+	story.switchTheme(config.options.txtTheme);
+	showBackstage = showBackstage !== undefined ? showBackstage : !readOnly;
+	t6 = new Date();
+	var m;
+	for(m in config.macros) {
+		if(config.macros[m].init)
+			config.macros[m].init();
+	}
+	t7 = new Date();
+	store.notifyAll();
+	t8 = new Date();
+	restart();
+	refreshDisplay();
+	t9 = new Date();
+	if(pluginProblem) {
+		story.displayTiddler(null,"PluginManager");
+		displayMessage(config.messages.customConfigError);
+	}
+	if(showBackstage)
+		backstage.init();
+	t10 = new Date();
+	if(config.options.chkDisplayInstrumentation) {
+		displayMessage("LoadShadows " + (t2-t1) + " ms");
+		displayMessage("LoadFromDiv " + (t3-t2) + " ms");
+		displayMessage("LoadPlugins " + (t5-t4) + " ms");
+		displayMessage("Macro init " + (t7-t6) + " ms");
+		displayMessage("Notify " + (t8-t7) + " ms");
+		displayMessage("Restart " + (t9-t8) + " ms");
+		displayMessage("Total: " + (t10-t0) + " ms");
+	}
+	startingUp = false;
+	doc.trigger("startup");
+}
+
+// Called on unload. All functions called conditionally since they themselves may have been unloaded.
+function unload()
+{
+	if(window.checkUnsavedChanges)
+		checkUnsavedChanges();
+	if(window.scrubNodes)
+		scrubNodes(document.body);
+}
+
+// Restarting
+function restart()
+{
+	invokeParamifier(params,"onstart");
+	if(story.isEmpty()) {
+		story.displayDefaultTiddlers();
+	}
+	window.scrollTo(0,0);
+}
+
+function saveTest()
+{
+	var s = document.getElementById("saveTest");
+	if(s.hasChildNodes())
+		alert(config.messages.savedSnapshotError);
+	s.appendChild(document.createTextNode("savetest"));
+}
+
+function loadShadowTiddlers()
+{
+	var shadows = new TiddlyWiki();
+	shadows.loadFromDiv("shadowArea","shadows",true);
+	shadows.forEachTiddler(function(title,tiddler){config.shadowTiddlers[title] = tiddler.text;});
+}
+
+function loadPlugins(tag)
+{
+	if(safeMode)
+		return false;
+	var tiddlers = store.getTaggedTiddlers(tag);
+	//# ensure the plugins are sorted into case sensitive order
+	tiddlers.sort(function(a,b) {return a.title < b.title ? -1 : (a.title == b.title ? 0 : 1);});
+	var toLoad = [];
+	var nLoaded = 0;
+	var map = {};
+	var nPlugins = tiddlers.length;
+	installedPlugins = [];
+	var i;
+	for(i=0; i<nPlugins; i++) {
+		var p = getPluginInfo(tiddlers[i]);
+		installedPlugins[i] = p;
+		var n = p.Name || p.title;
+		if(n)
+			map[n] = p;
+		n = p.Source;
+		if(n)
+			map[n] = p;
+	}
+	var visit = function(p) {
+		if(!p || p.done)
+			return;
+		p.done = 1;
+		var reqs = p.Requires;
+		if(reqs) {
+			reqs = reqs.readBracketedList();
+			var i;
+			for(i=0; i<reqs.length; i++)
+				visit(map[reqs[i]]);
+		}
+		toLoad.push(p);
+	};
+	for(i=0; i<nPlugins; i++)
+		visit(installedPlugins[i]);
+	for(i=0; i<toLoad.length; i++) {
+		p = toLoad[i];
+		pluginInfo = p;
+		tiddler = p.tiddler;
+		if(isPluginExecutable(p)) {
+			if(isPluginEnabled(p)) {
+				p.executed = true;
+				var startTime = new Date();
+				try {
+					if(tiddler.text)
+						window.eval(tiddler.text);
+					nLoaded++;
+				} catch(ex) {
+					p.log.push(config.messages.pluginError.format([exceptionText(ex)]));
+					p.error = true;
+					if(!console.tiddlywiki) {
+						console.log("error evaluating " + tiddler.title, ex);
+					}
+				}
+				pluginInfo.startupTime = String((new Date()) - startTime) + "ms";
+			} else {
+				nPlugins--;
+			}
+		} else {
+			p.warning = true;
+		}
+	}
+	return nLoaded != nPlugins;
+}
+
+function getPluginInfo(tiddler)
+{
+	var p = store.getTiddlerSlices(tiddler.title,["Name","Description","Version","Requires","CoreVersion","Date","Source","Author","License","Browsers"]);
+	p.tiddler = tiddler;
+	p.title = tiddler.title;
+	p.log = [];
+	return p;
+}
+
+// Check that a particular plugin is valid for execution
+function isPluginExecutable(plugin)
+{
+	if(plugin.tiddler.isTagged("systemConfigForce")) {
+		plugin.log.push(config.messages.pluginForced);
+		return true;
+	}
+	if(plugin["CoreVersion"]) {
+		var coreVersion = plugin["CoreVersion"].split(".");
+		var w = parseInt(coreVersion[0],10) - version.major;
+		if(w == 0 && coreVersion[1])
+			w = parseInt(coreVersion[1],10) - version.minor;
+		if(w == 0 && coreVersion[2])
+			w = parseInt(coreVersion[2],10) - version.revision;
+		if(w > 0) {
+			plugin.log.push(config.messages.pluginVersionError);
+			return false;
+		}
+	}
+	return true;
+}
+
+function isPluginEnabled(plugin)
+{
+	if(plugin.tiddler.isTagged("systemConfigDisable")) {
+		plugin.log.push(config.messages.pluginDisabled);
+		return false;
+	}
+	return true;
+}
+

test/tiddlywiki.2.6.5/source/tiddlywiki/js/split.recipe

@@ -0,0 +1,54 @@
+version: Version.js
+js: Guide.js
+js: Config.js
+js: ConfigBrowser.js
+js: Lingo.js
+js: main.js
+js: Paramifiers.js
+js: FormatterHelpers.js
+js: Formatter.js
+js: Wikifier.js
+js: Macros.js
+js: NewTiddler.js
+js: Search.js
+js: Tabs.js
+js: Toolbar.js
+js: Commands.js
+js: Tiddler.js
+js: TiddlyWiki.js
+js: Filters.js
+js: TiddlerFields.js
+js: Story.js
+js: Backstage.js
+js: Import.js
+js: Upgrade.js
+js: Sync.js
+js: Manager.js
+js: Messages.js
+js: Refresh.js
+js: Options.js
+js: Saving.js
+js: SavingRSS.js
+js: FileSystem.js
+js: AdaptorBase.js
+js: FileAdaptor.js
+js: Http.js
+js: Utilities.js
+js: UtilitiesPopup.js
+js: Animator.js
+js: Morpher.js
+js: Zoomer.js
+js: Scroller.js
+js: Slider.js
+js: Popup.js
+js: Wizard.js
+js: ListView.js
+js: BasicTypes.js
+js: Strings.js
+js: Dates.js
+js: RGB.js
+js: Dom.js
+js: LoaderSaver.js
+js: TW21Loader.js
+js: TW21Saver.js
+