abegoExtensions

IncludePlugin

Mon, 01 Oct 2012 19:45:41 GMT

Name:	abego.IncludePlugin
Version:	1.0.1 (2007-04-30)
Type:	plugin
Source:	http://tiddlywiki.abego-software.de/#IncludePlugin
Author:	Udo Borkowski (ub [at] abego-software [dot] de)
Documentation:	IncludePlugin Documentation
Community:	(del.icio.us) (Support)
Copyright:	© 2007 abego Software
Licence:	BSD open source license (abego Software)
CoreVersion:	2.1.3
Browser:	Firefox 1.5.0.9 or better; Internet Explorer 6.0

Revision history

The IncludePlugin is no longer in active development. If you are experiencing problems or looking for some additional features you may want have a look at the SharedTiddlersPlugin.

1.0.1 (2007-04-30)
- Make ForEachTiddler "Include-aware"
1.0.0 (2007-02-08)
- initial version

Source Code

This plugin's source code is compressed (and hidden). Use this link to get the readable source code.

YourSearchPlugin v2.1.6 released

Thu, 19 Apr 2012 02:58:00 GMT

Fix issue when using YourSearchPlugin with Internet Explorer 8. Thanks to Roger Gallion for reporting and providing the fix. (For details see: https://github.com/abego/YourSearchPlugin/issues/1)

FormTiddlerPlugin

Wed, 18 Apr 2012 23:03:00 GMT

Name:	FormTiddlerPlugin
Version:	1.0.7 (2012-04-19)
Summary:	Use form-based tiddlers to enter your tiddler data using text fields, listboxes, checkboxes etc. (All standard HTML Form input elements supported).
Documentation:	Introduction, Examples
Source:	http://tiddlywiki.abego-software.de/#FormTiddlerPlugin
Twitter:	@abego
Author:	UdoBorkowski (ub [at] abego-software [dot] de)
License:	BSD open source license
Requires:	DataTiddlerPlugin

Description

Use form-based tiddlers to enter your tiddler data using text fields, listboxes, checkboxes etc. (All standard HTML Form input elements supported).

Syntax:

`<<`formTiddler tiddlerName`>>`
tiddlerName	The name of the FormTemplate tiddler to be used to edit the data of the tiddler containing the macro.

`<<`newTiddlerWithForm formTemplateName buttonLabel [titleExpression [askUser]] `>>`
formTemplateName	The name of the tiddler that defines the form the new tiddler should use.
buttonLabel	The label of the button
titleExpression	A (quoted) JavaScript String expression that defines the title (/name) of the new tiddler.
askUser	Typically the user is not asked for the title when a title is specified (and not yet used). When askUser is given the user will be asked in any case. This may be used when the calculated title is just a suggestion that must be confirmed by the user
_{Syntax formatting: Keywords in bold, optional parts in [...]. 'or' means that exactly one of the two alternatives must exist.}

For details and how to use the macros see the introduction and the examples.

Source Code

This plugin's source code is compressed (and hidden).
Use this link to get the readable source code.

YourSearchPlugin

Wed, 18 Apr 2012 23:02:00 GMT

Name:	YourSearchPlugin
Version:	2.1.6 (2012-04-19)
Summary:	Search your TiddlyWiki with advanced search features such as result lists, tiddler preview, result ranking, search filters, combined searches and many more.
Source:	http://tiddlywiki.abego-software.de/#YourSearchPlugin
Twitter:	@abego
GitHub:	https://github.com/abego/YourSearchPlugin
Author:	UdoBorkowski (ub [at] abego-software [dot] de)
License:	BSD open source license

About YourSearch

YourSearch gives you a bunch of new features to simplify and speed up your daily searches in TiddlyWiki. It seamlessly integrates into the standard TiddlyWiki search: just start typing into the 'search' field and explore!

For more information see Help.

Compatibility

This plugin requires TiddlyWiki 2.1.
Check the archive for YourSearchPlugins supporting older versions of TiddlyWiki.

Source Code

This plugin's source code is compressed (and hidden).
Use this link to get the readable source code.

DataTiddlerPlugin

Wed, 18 Apr 2012 23:01:00 GMT

Name:	DataTiddlerPlugin
Version:	1.0.7 (2012-04-19)
Summary:	Enhance your tiddlers with structured data (such as strings, booleans, numbers, or even arrays and compound objects) that can be easily accessed and modified through named fields (in JavaScript code).
Source:	http://tiddlywiki.abego-software.de/#DataTiddlerPlugin
Twitter:	@abego
Author:	UdoBorkowski (ub [at] abego-software [dot] de)
License:	BSD open source license

Description

Enhance your tiddlers with structured data (such as strings, booleans, numbers, or even arrays and compound objects) that can be easily accessed and modified through named fields (in JavaScript code).

Such tiddler data can be used in various applications. E.g. you may create tables that collect data from various tiddlers.

Example: "Table with all December Expenses"

<<forEachTiddler
    where
        'tiddler.tags.contains("expense") && tiddler.data("month") == "Dec"'
    write
        '"|[["+tiddler.title+"]]|"+tiddler.data("descr")+"| "+tiddler.data("amount")+"|\n"'
>>

(This assumes that expenses are stored in tiddlers tagged with "expense".)

Invoice Carvers	Restaurant	35
InvoiceKLM	Flight	688
Receipt Four Seasons	Hotel	149

For other examples see DataTiddlerExamples.

Access and Modify Tiddler Data

You can "attach" data to every tiddler by assigning a JavaScript value (such as a string, boolean, number, or even arrays and compound objects) to named fields.

These values can be accessed and modified through the following Tiddler methods:

Method	Example	Description
`data(field)`	`t.data("age")`	Returns the value of the given data field of the tiddler. When no such field is defined or its value is undefined `undefined` is returned.
`data(field,defaultValue)`	`t.data("isVIP",false)`	Returns the value of the given data field of the tiddler. When no such field is defined or its value is undefined the defaultValue is returned.
`data()`	`t.data()`	Returns the data object of the tiddler, with a property for every field. The properties of the returned data object may only be read and not be modified. To modify the data use DataTiddler.setData(...) or the corresponding Tiddler method.
`setData(field,value)`	`t.setData("age",42)`	Sets the value of the given data field of the tiddler to the value. When the value is `undefined` the field is removed.
`setData(field,value,defaultValue)`	`t.setData("isVIP",flag,false)`	Sets the value of the given data field of the tiddler to the value. When the value is equal to the defaultValue no value is set (and the field is removed).

Alternatively you may use the following functions to access and modify the data. In this case the tiddler argument is either a tiddler or the name of a tiddler.

Method	Description
`DataTiddler.getData(tiddler,field)`	Returns the value of the given data field of the tiddler. When no such field is defined or its value is undefined `undefined` is returned.
`DataTiddler.getData(tiddler,field,defaultValue)`	Returns the value of the given data field of the tiddler. When no such field is defined or its value is undefined the defaultValue is returned.
`DataTiddler.getDataObject(tiddler)`	Returns the data object of the tiddler, with a property for every field. The properties of the returned data object may only be read and not be modified. To modify the data use DataTiddler.setData(...) or the corresponding Tiddler method.
`DataTiddler.setData(tiddler,field,value)`	Sets the value of the given data field of the tiddler to the value. When the value is `undefined` the field is removed.
`DataTiddler.setData(tiddler,field,value,defaultValue)`	Sets the value of the given data field of the tiddler to the value. When the value is equal to the defaultValue no value is set (and the field is removed).

(For details on the various functions see the detailed comments in the source code.)

Data Representation in a Tiddler

The data of a tiddler is stored as plain text in the tiddler's content/text, inside a "data" section that is framed by a <data>...</data> block. Inside the data section the information is stored in the JSON format.

Data Section Example:

<data>{"isVIP":true,"user":"John Brown","age":34}</data>

The data section is not displayed when viewing the tiddler (see also "The showData Macro").

Beside the data section a tiddler may have all kind of other content.

Typically you will not access the data section text directly but use the methods given above. Nevertheless you may retrieve the text of the data section's content through the DataTiddler.getDataText(tiddler) function.

Saving Changes

The "setData" methods respect the "ForceMinorUpdate" and "AutoSave" configuration values. I.e. when "ForceMinorUpdate" is true changing a value using setData will not affect the "modifier" and "modified" attributes. With "AutoSave" set to true every setData will directly save the changes after a setData.

Notifications

No notifications are sent when a tiddler's data value is changed through the "setData" methods.

Escape Data Section
In case that you want to use the text <data> or </data> in a tiddler text you must prefix the text with a tilde ('~'). Otherwise it may be wrongly considered as the data section. The tiddler text ~<data> is displayed as <data>.

The showData Macro

By default the data of a tiddler (that is stored in the <data>...</data> section of the tiddler) is not displayed. If you want to display this data you may used the <<showData ...>> macro:

Syntax:

`<<`showData [JSON] [tiddlerName] `>>`
JSON	By default the data is rendered as a table with a "Name" and "Value" column. When defining JSON the data is rendered in JSON format
tiddlerName	Defines the tiddler holding the data to be displayed. When no tiddler is given the tiddler containing the showData macro is used. When the tiddler name contains spaces you must quote the name (or use the `[[...]]` syntax.)
_{Syntax formatting: Keywords in bold, optional parts in [...]. 'or' means that exactly one of the two alternatives must exist.}

Source Code

This plugin's source code is compressed (and hidden).
Use this link to get the readable source code.

abegoExtensions News

Wed, 18 Apr 2012 22:40:00 GMT

2012-04-19

2012-04-09

Added compatibility note in DataTiddlerPlugin on tiddlers with spaces in their titles when using TiddlyWiki > 2.6.2. Thanks to Matt Shanks for reporting this.

2011-09-29

Added info on using the IncludePlugin in the Opera or Chrome browser. Thanks to Yakov Litvin for this.

2011-05-23

Release PartTiddlerPlugin v1.0.10
- Adapt to TW 2.6.2 default behaviour when existing tiddlers are opened (don't select text) and fixed Firefox 4 issue. Thanks to dave for reporting the issue.

2011-01-20

Added the ForEachTiddlerPlugin example 'Create a table with one column per tiddler ("Vertical Report")' and 'Create a table with one row per tiddler ("Horizontal Report")'.

2010-02-16

YourSearchPlugin v2.1.5 released
- Fixed problems with CSS and search textfield. Thanks to Guido Glatzel for reporting.

2009-12-29

Added the ForEachTiddlerPlugin example 'List all tasks completed on a journal tiddler's day, as a "Daily Status Report"'. Based on an idea by cmari and Alan Cohen. Thanks.

2009-10-09

Revised the NewTiddlerWithFormMacro documentation

2009-09-04

YourSearchPlugin v2.1.4 released
- Fixed "this command is not supported" error under IE 8. Thanks to rouilj for reporting. (For details see: http://groups.google.com/group/TiddlyWiki/browse_thread/thread/cffee3254381e478)

2008-05-04

Improved TiddlyWiki style for better appearance in Safari

2008-04-16

YourSearchPlugin v2.1.3 released
- Fixed problem with Firefox3. Thanks to Andreas Hoefler for reporting.

2008-03-17

YourSearchPlugin v2.1.2 released
- Bugfix: on IE (6.0) the first letter is dropped from the search string. Thanks to Kashgarinn and Nick Padfield for reporting.

^{For older news see the revision history of the various plugins.}

FormTiddlerPlugin v1.0.7 and DataTiddlerPlugin v1.0.7 released

Wed, 18 Apr 2012 22:26:00 GMT

This release fixes incompatibilities of the FormTiddlerPlugin and DataTiddlerPlugin with newer TiddlyWiki versions.

Details:

FormTiddlerPlugin v1.0.7
- Bugfix: FormTiddlerPlugin fails to handle tiddlers with certain names in TW 2.6.5. Thanks to Terence Jacyno, Thomas Manley, Sebastjan Hribar, and Eric Shulman for reporting or suggesting a solution.
DataTiddlerPlugin v1.0.7
- Bugfix: showData macro fails in TW 2.6.5 when tiddler title contains spaces. Thanks to Matt Shanks and Terence Jacyno for reporting.

Plugins

Tue, 17 Apr 2012 19:54:00 GMT

Plugin	Description
AutoRefreshPlugin	A tiddler containing the `<<autoRefresh...>>` macro is automatically refreshed (re-painted) whenever a tiddler changes.
DataTiddlerPlugin	Enhance your tiddlers with structured data (such as strings, booleans, numbers, or even arrays and compound objects) that can be easily accessed and modified through named fields (in JavaScript code).
ForEachTiddlerPlugin	Create customizable lists, tables etc. for your selections of tiddlers. Specify the tiddlers to include and their order through a powerful language.
FormTiddlerPlugin	Use form-based tiddlers to enter your tiddler data using text fields, listboxes, checkboxes etc. (All standard HTML Form input elements supported).
IncludePlugin	„Include“ other TiddlyWikis in your „main“ TiddlyWiki, link to included tiddlers, view them in your „main“ TiddlyWiki (without opening another TiddlyWiki). Even „search“ looks for included tiddlers. A great way to share tiddlers, to speed up "save changes" and to keep your TiddlyWikis small.
IntelliTaggerPlugin	Speed up tagging tiddlers using tag autocompletion and correction, tag suggestions and context sensitive tag guessing, "Edit Tags only" mode and many more. Especially when you are working with a lot of tags this is the plugin you are looking for.
IntelliTagsEditCommandPlugin	A command for your tiddler's toolbar to directly edit the tiddler's tags using the IntelliTaggerPlugin, without switching to "edit mode".
PartTiddlerPlugin	With the `<part aPartName> ... </part>` feature you can structure your tiddler text into separate parts. Each part can be referenced as a "normal" tiddler, using the "tiddlerName/partName" syntax.
SettingsPlugin	Manage your option settings' scope: keep settings private to a TiddlyWiki or share them with other TiddlyWikis.
TiddlerWithParamsPlugin	The plugin extends the build-in `<<tiddler...>>` macro. It replaces placeholders ($1, $2, ...) in the tiddler by values passed with the macro before it inserts the (replaced) text at the macro's location.
XHTML10Plugin	Make your TiddlyWiki XHTML 1.0 compliant.
YourSearchPlugin	Search your TiddlyWiki with advanced search features such as result lists, tiddler preview, result ranking, search filters, combined searches and many more.

Read Installing Plugins on how to install these plugins in your TiddlyWiki.

Previous versions of these plugins (e.g. to run in older versions of TiddlyWiki) you may find in the archive.

XHTML10Plugin

Mon, 16 Apr 2012 21:38:00 GMT

Name:	XHTML10Plugin
Version:	1.0.1 (2006-09-16)
Source:	http://tiddlywiki.abego-software.de/#XHTML10Plugin
Author:	UdoBorkowski (ub [at] abego-software [dot] de)
Licence:	BSD open source license (abego Software)
Copyright:	© 2005-2006 abego Software
CoreVersion:	2.1.0
Browser:	Firefox 1.5.0.2 or better; Internet Explorer 6.0

Make your TiddlyWiki XHTML 1.0 compliant format.

Once the plugin is installed the existing tiddlers of that TiddlyWiki are automatically converted to the new (XHTML 1.0 compliant) format on the first save. After that all changes are stored in the XHTML format.

Source Code

// Ensure the Plugin is only installed once.
//
if (!version.extensions.XHTML10Plugin) {

if (version.major < 2 || (version.major == 2 && version.minor < 1)) {
	(function() {
		var s = "Use TiddlyWiki 2.1 or better to run the XHTML10Plugin.";
		alert(s);
		throw s;
	})();
}

version.extensions.XHTML10Plugin = {
	major: 1, minor: 0, revision: 1,
	date: new Date(2006, 8, 16),
	source: "http://tiddlywiki.abego-software.de/#XHTML10Plugin",
	licence: "[[BSD open source license (abego Software)|http://www.abego-software.de/legal/apl-v10.html]]",
	copyright: "Copyright (c) abego Software GmbH, 2005-2006 (www.abego-software.de)",
};

// Ensure the global abego namespace is set up.
if (!window.abego) window.abego = {};


//--------------------------------
// XHTML10Saver (inherits from SaverBase)

abego.XHTML10Saver = function() {};

abego.XHTML10Saver.prototype = new SaverBase();

abego.XHTML10Saver.prototype.externalizeTiddler = function(store, tiddler) {
	try {
		var s = '';
		store.forEachField(tiddler, 
			function(tiddler, fieldName, value) {
				// don't store stuff from the temp namespace
				if (!fieldName.match(/^temp\./)) {
					if (value)
						value = value.htmlEncode();
					s += ['<pre title="',fieldName,'">',value,'</pre>'].join("");
				}
			});
		return ['<div title="',tiddler.title.htmlEncode(),'">',s,'</div>'].join("");

	} catch (e) {
		showException(e, config.messages.tiddlerSaveError.format([tiddler.title]));
		return '';
	}
};

abego.XHTML10Saver.prototype.externalize = function(store) {
	return ["<div class='twXHTML10'>\n",SaverBase.prototype.externalize.apply(this, arguments),"\n</div>"].join("");
};


//--------------------------------
// Overwrite TiddlyWiki.prototype.getSaver to use the XHTML10 format on save

TiddlyWiki.prototype.getSaver = function() {
	if (!this.saver) 
		this.saver = new abego.XHTML10Saver();
	return this.saver;
};

//======================================
// Install the Loader into the HTML page

(function() {
	// The loader code will be inserted into the PostHead markup block,
	// so it can be executed before tiddlers are loaded. We cannot just put this
	// code into a normal plugin since this "load" code is required to load
	// tiddlers. I.e. this code must be executed before any tiddlers/plugins
	// can be loaded.

	var getXHTML10LoaderBlock = function() {
		// The loader code in a big JavaScript string.
		// You may get a non-stringified version of the XHTML10Loader source code at
		// http://tiddlywiki.abego-software.de/archive/XHTML10Plugin/1.0.1/XHTML10Plugin-1.0.1-loader.js

		XHTML10LoaderCode = 
			"if (!window.abego) window.abego = {};\nif (!abego.XHTML10Loader) {\n\t//-"+
			"-------------------------------\n\t// abego.XHTML10Loader (inherits from"+
			" LoaderBase)\n\t\n\tabego.XHTML10Loader = function() {};\n\tabego.XHTML10Loa"+
			"der.prototype = new LoaderBase();\n\t\n\tabego.XHTML10Loader.prototype.lin"+
			"go = {\n\t\tunnamedValue: \"Unnamed value\",\n\t\tredefining: \"Redefining valu"+
			"e of %0\",\n\t\tnoXHTML10Format: \"Storage not in XHTML 1.0 format\"\n\t}\n\t\n\ta"+
			"bego.XHTML10Loader.prototype.getTitle = function(store, e) {\n\t\tvar tit"+
			"le = null;\n\t\tif(e.getAttribute)\n\t\t\ttitle = e.getAttribute('title');\n\t\t"+
			"if(!title && e.id) {\t\n\t\t\tvar lenPrefix = store.idPrefix.length;\n\t\t\tif "+
			"(e.id.substr(0,lenPrefix) == store.idPrefix)\n\t\t\t\ttitle = e.id.substr(l"+
			"enPrefix);\n\t\t}\n\t\treturn title;\n\t};\n\t\n\tabego.XHTML10Loader.prototype.in"+
			"ternalizeTiddler = function(store, tiddler, title, data) {\n\t\tvar field"+
			"s = {};\n\t\tvar elems = data.childNodes;\n\t\tfor(var i = 0; i < elems.leng"+
			"th; i++) {\n\t\t\tvar e = elems[i];\n\t\t\tvar name = e.getAttribute('title');"+
			"\n\t\t\tif (!name) \n\t\t\t\tthrow this.lingo.unnamedValue;\n\t\t\tif (fields[name]"+
			" !== undefined) \n\t\t\t\tthrow this.lingo.redefining.format([name]);\n\t\t\tfi"+
			"elds[name] = getNodeText(e.firstChild); \n\t\t}\n\t\n\t\t// Extract (and remov"+
			"e) the standard fields from the extended fields\n\t\tvar text = fields.te"+
			"xt;\n\t\tvar modifier = fields.modifier;\n\t\tvar modified = Date.convertFro"+
			"mYYYYMMDDHHMM(fields.modified);\n\t\tvar c = fields.created;\n\t\tvar create"+
			"d = c ? Date.convertFromYYYYMMDDHHMM(c) : modified;\n\t\tvar tags = field"+
			"s.tags;\n\t\tdelete fields.modifier;\n\t\tdelete fields.modified;\n\t\tdelete f"+
			"ields.created;\n\t\tdelete fields.tags;\n\t\tdelete fields.text;\n\t\tdelete fi"+
			"elds.title;\n\t\n\t\ttiddler.assign(title,text,modifier,modified,tags,creat"+
			"ed,fields);\n\t\t\n\t\treturn tiddler;\n\t};\n\t\n\tvar findRootNode = function(no"+
			"des) {\n\t\tif (nodes) {\n\t\t\t// skip leading text nodes\n\t\t\tfor (var i = 0;"+
			" i < nodes.length; i++)\n\t\t\t\tif (nodes[i].nodeType != 3)\n\t\t\t\t\tbreak;\n\t\t"+
			"\t\t\t\n\t\t\tif (i < nodes.length && nodes[i].className == 'twXHTML10')\n\t\t\t\t"+
			"return nodes[i];\n\t\t}\n\t};\n\t\n\tabego.XHTML10Loader.prototype.loadTiddlers"+
			" = function(store,nodes) {\n\t\t// in the twXHMTL10 format all tiddler el"+
			"ements are contained in one enclosing DIV\n\t\t// that contains the forma"+
			"t information\n\t\tvar root = findRootNode(nodes)\n\t\tif (!root) \n\t\t\tthrow "+
			"this.lingo.noXHTML10Format;\n\t\treturn LoaderBase.prototype.loadTiddlers"+
			".apply(this, [store, root.childNodes]);\n\t};\n\t\n\t\n\t//-------------------"+
			"-------------\n\t// Hijack the loadFromDiv\n\t(function() {\n\t\tvar origTidd"+
			"lyWikiLoadFromDiv = TiddlyWiki.prototype.loadFromDiv;\n\t\tTiddlyWiki.pro"+
			"totype.loadFromDiv = function(srcID,idPrefix) {\n\t\t\t// use the XHTML 1."+
			"0 loader when the storearea is in 'twXHTML10' format,\n\t\t\t// otherwise "+
			"use the default loader\n\t\t\tvar e = document.getElementById(srcID);\n\t\t\ti"+
			"f (e && findRootNode(e.childNodes))\n\t\t\t\tthis.loader = new abego.XHTML1"+
			"0Loader();\n\t\t\treturn origTiddlyWikiLoadFromDiv.apply(this, arguments);"+
			"\n\t\t};\n\t})();\n}\n\n";
		return '<'+'script type="text/javascript">\n//<![CDATA[\n'+XHTML10LoaderCode+'\n//]]>\n</script'+'>\n';
	};

	var insertLoaderBlock = function() {
		if (!store)
			throw "XHTML10LoaderInstaller must run as a plugin";
			
		var START = "<!--XHMTL10Loader-START-->";
		var END = "<!--XHMTL10Loader-END-->";
		
		var postHeadText = store.getTiddlerText("MarkupPostHead");
		if (postHeadText.getChunk(START, END)) 
			return; // already installed

		postHeadText += "\n"+START+getXHTML10LoaderBlock()+END+"\n";
		var tiddler = store.getTiddler("MarkupPostHead");
		var tags = tiddler ? tiddler.tags : [];
		store.saveTiddler("MarkupPostHead","MarkupPostHead",postHeadText,config.options.txtUserName,new Date(),tags);
		alert("XHTML10Loader installed.\nPlease save and reload your TiddlyWiki to complete the installation. After that your TiddlyWiki will be stored in an XHTML 1.0 compliant format.");
	};
	
	insertLoaderBlock();														
})();

} // of single install

TiddlerWithParamsPlugin

Mon, 16 Apr 2012 21:38:00 GMT

Name:	TiddlerWithParamsPlugin
Version:	1.0.1 (2006-03-22)
Source:	http://tiddlywiki.abego-software.de/#TiddlerWithParamsPlugin
Author:	UdoBorkowski (ub [at] abego-software [dot] de)
Licence:	BSD open source license

Description

The TiddlerWithParamsPlugin extends the build-in <<tiddler...>> macro. It replaces placeholders ($1, $2, ...) in the given tiddler by values passed with the macro. Then it inserts the (replaced) text, just like the original <<tiddler...>> macro.

Syntax:

`<<`tiddler tiddlerName [className] [asText] [with: arguments ] [prefix: prefixString] `>>`
tiddlerName	The name of the tiddler to be included. The tiddler may contain placeholders ($1, $2, ... $9) that will be replaced with the values passed with the macro
className	The (CSS) class to be used around the embedded tiddler
asText	When defined the (replaced) content of the tiddler is inserted as pure text, i.e. it is not "wikified".
arguments	up to 9 arguments may be passed to the macro, used as the values for the placeholders $1, $2, ... $9 in the referenced template
prefixString	By default the placeholders $1, $2, $3,..., $9 are used. But you may change the "prefix" before the placeholder number ("$") to some other text through the "prefix:" option. This may be necessary when you are using the $n in the tiddler you are referencing (e.g. when you are using regular expressions).
_{Syntax formatting: Keywords in bold, optional parts in [...].}

Example

The following ProjectTemplate tiddler defines an "Overview" page for a project, that gives access to various "sub-tiddlers" used in the project, that follow a static naming schema (e.g. all Notes for any project are stored in a tiddler called "projectName Notes"). $1 holds the name of the Project (e.g. "ForEachTiddler"), $2 holds the type of the published component (e.g. "Plugin", "Macro", "Function").

![[$1Project]] Overview
* [[$1$2]]
* [[ToDo|$1 ToDos]]
* [[Notes|$1 Notes]]
* [[Examples|$1Examples]]
* [[Tests|$1 Tests]]
* [[Open Bugs/CRs|$1 Open Bugs and ChangeRequests]]

This template is now used in the ForEachTiddlerProject tiddler:

<<tiddler ProjectTemplate with: ForEachTiddler Plugin>>

This results in the following tiddler text for the ForEachTiddlerProject tiddler:

![[ForEachTiddlerProject]] Overview
* [[ForEachTiddlerPlugin]]
* [[ToDo|ForEachTiddler ToDos]]
* [[Notes|ForEachTiddler Notes]]
* [[Examples|ForEachTiddlerExamples]]
* [[Tests|ForEachTiddler Tests]]
* [[Open Bugs/CRs|ForEachTiddler Open Bugs and ChangeRequests]]

Revision history

v1.0.0 (2006-01-20)
- initial version
v1.0.1 (2006-03-22)
- Added 'asText' option
- Support Safari (Thanks to Elise Springer for reporting the problem)

Code

//============================================================================
// TiddlerWithParamsPlugin
//============================================================================

// Ensure that the Plugin is only installed once.
//
if (!version.extensions.TiddlerWithParamsPlugin) {

version.extensions.TiddlerWithParamsPlugin = {
	major: 1, minor: 0, revision: 1, 
	date: new Date(2006,3,22), 
	type: 'plugin',
	source: "http://tiddlywiki.abego-software.de/#TiddlerWithParamsPlugin"
};

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

var indexInArray = function(array, item) {
	for (var i = 0; i < array.length; i++) {
		if (array[i] == item) {
			return i;
		}
	}
	return -1;
}

var myEscapeRegExp = function(s)
{
	// The original escapeRegExp function does not work with Safari (2.0.3) 
	// since the $& is not implemented.
var t = s.replace(/\\/g, "\\\\");
	t = t.replace(/\^/g, "\\^");
	t = t.replace(/\$/g, "\\$");
	t = t.replace(/\*/g, "\\*");
	t = t.replace(/\+/g, "\\+");
	t = t.replace(/\?/g, "\\?");
	t = t.replace(/\(/g, "\\(");
	t = t.replace(/\)/g, "\\)");
	t = t.replace(/\=/g, "\\=");
	t = t.replace(/\!/g, "\\!");
	t = t.replace(/\|/g, "\\|");
	t = t.replace(/\,/g, "\\,");
	t = t.replace(/\{/g, "\\{");
	t = t.replace(/\}/g, "\\}");
	t = t.replace(/\[/g, "\\[");
	t = t.replace(/\]/g, "\\]");
	t = t.replace(/\./g, "\\.");

    return t;
}

// ---------------------------------------------------------------------------
// The (hijacked) tiddler Macro Handler 
// ---------------------------------------------------------------------------

config.macros.tiddler.handler = function(place,macroName,params,wikifier,paramString,tiddler) {
	
	var className = null;
	var argsStart = -1;
	var doWikify = true;

	var iParams = 1;
	if (params[iParams] != "asText" && params[iParams] != "with:") {
		className = params[iParams++];
	}
	if (params[iParams] == "asText") {
		iParams++;
		doWikify = false;
	}
	if (params[iParams] == "with:") {
		iParams++;
		argsStart = iParams;
	}
	
	var wrapper = createTiddlyElement(place,"span",null,className ? className : null,null);
	var text = store.getTiddlerText(params[0]);
	if(text) {
		// Check for recursion
		var tiddlerName = params[0];
		var stack = config.macros.tiddler.tiddlerStack;
		if (stack.find(tiddlerName) !== null) return;

		if (argsStart >= 0) {
			// The params between the "with:" and the "prefix:" (or the end) are the arguments,
			// The param behind the "prefix:" is the prefix before the placeholder numbers.
			var argsEnd = params.length;
			var prefix = "$";
			var prefixIndex = indexInArray(params, "prefix:");
			if (prefixIndex >= argsStart) {
				argsEnd = prefixIndex;
				if (prefixIndex < (params.length-1)) {
					prefix = params[prefixIndex+1];
				}
			}
			// to avoid any "special RE chars" problems with the prefix string escape all chars.
			prefix = myEscapeRegExp(prefix);
			
			var args = params.slice(argsStart, argsEnd);
			var n = Math.min(args.length, 9);
			for (var i = 0; i < n; i++) {
				var value = args[i];
				
				var placeholderRE = new RegExp(prefix+(i+1),"mg");
				text = text.replace(placeholderRE, value);
			}
		}
		stack.push(tiddlerName);
		try {
			if (doWikify) {
				wikify(text,wrapper,null,store.getTiddler(params[0]));
			} else {
				wrapper.appendChild(document.createTextNode(text));
			}
		} finally {			
			stack.pop();
		}
	}
}
config.macros.tiddler.tiddlerStack = [];

// End of "install only once"
}

//============================================================================
// End of TiddlerWithParamsPlugin
//============================================================================

Licence and Copyright

Copyright (c) abego Software GmbH, 2006 (www.abego-software.de)

Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.

Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or other
materials provided with the distribution.

Neither the name of abego Software nor the names of its contributors may be
used to endorse or promote products derived from this software without specific
prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.

PartTiddlerPlugin

Mon, 16 Apr 2012 21:38:00 GMT

Name:	PartTiddlerPlugin
Version:	1.0.10 (2011-05-23)
Source:	http://tiddlywiki.abego-software.de/#PartTiddlerPlugin
Author:	UdoBorkowski (ub [at] abego-software [dot] de)
Licence:	BSD open source license
CoreVersion:	2.1.3
Browser:	Firefox 1.0.4+; InternetExplorer 6.0

Table of Content

Description

With the <part aPartName> ... </part> feature you can structure your tiddler text into separate (named) parts.
Each part can be referenced as a "normal" tiddler, using the "tiddlerName/partName" syntax (e.g. "About/Features"). E.g. you may create links to the parts (e.g. [[Quotes/BAX95]] or [[Hobbies|AboutMe/Hobbies]]), use it in <<tiddler...>> or <<tabs...>> macros etc.

Syntax:

<part partName [hidden] > any tiddler content </part>
partName	The name of the part. You may reference a part tiddler with the combined tiddler name "nameOfContainerTidder/partName. If you use a partName containing spaces you need to quote it (e.g. `"Major Overview"` or `[[Shortcut List]]`).
hidden	When defined the content of the part is not displayed in the container tiddler. But when the part is explicitly referenced (e.g. in a `<<tiddler...>>` macro or in a link) the part's content is displayed.
any tiddler content	The content of the part. A part can have any content that a "normal" tiddler may have, e.g. you may use all the formattings and macros defined.
_{Syntax formatting: Keywords in bold, optional parts in [...]. 'or' means that exactly one of the two alternatives must exist.}

_[Top]

Applications

Refering to Paragraphs of a Longer Tiddler

Assume you have written a long description in a tiddler and now you want to refer to the content of a certain paragraph in that tiddler (e.g. some definition.) Just wrap the text with a part block, give it a nice name, create a "pretty link" (like [[Discussion Groups|Introduction/DiscussionGroups]]) and you are done.

Notice this complements the approach to first writing a lot of small tiddlers and combine these tiddlers to one larger tiddler in a second step (e.g. using the <<tiddler...>> macro). Using the part feature you can first write a "classic" (longer) text that can be read "from top to bottom" and later "reuse" parts of this text for some more "non-linear" reading.

_[Top]

Citation Index

Create a tiddler "Citations" that contains your "citations".
Wrap every citation with a part and a proper name.

Example

<part BAX98>Baxter, Ira D. et al: //Clone Detection Using Abstract Syntax Trees.// 
in //Proc. ICSM//, 1998.</part>

<part BEL02>Bellon, Stefan: //Vergleich von Techniken zur Erkennung duplizierten Quellcodes.// 
Thesis, Uni Stuttgart, 2002.</part>

<part DUC99>Ducasse, St�fane et al: //A Language Independent Approach for Detecting Duplicated Code.// 
in //Proc. ICSM//, 1999.</part>

You may now "cite" them just by using a pretty link like [[Citations/BAX98]] or even more pretty, like this [[BAX98|Citations/BAX98]].

_[Top]

Creating "multi-line" Table Cells

You may have noticed that it is hard to create table cells with "multi-line" content. E.g. if you want to create a bullet list inside a table cell you cannot just write the bullet list

* Item 1
* Item 2
* Item 3

into a table cell (i.e. between the | ... | bars) because every bullet item must start in a new line but all cells of a table row must be in one line.

Using the part feature this problem can be solved. Just create a hidden part that contains the cells content and use a <<tiddler >> macro to include its content in the table's cell.

Example

|!Subject|!Items|
|subject1|<<tiddler ./Cell1>>|
|subject2|<<tiddler ./Cell2>>|

<part Cell1 hidden>
* Item 1
* Item 2
* Item 3
</part>
...

Notice that inside the <<tiddler ...>> macro you may refer to the "current tiddler" using the ".".

BTW: The same approach can be used to create bullet lists with items that contain more than one line.

_[Top]

Creating Tabs

The build-in <<tabs ...>> macro requires that you defined an additional tiddler for every tab it displays. When you want to have "nested" tabs you need to define a tiddler for the "main tab" and one for every tab it contains. I.e. the definition of a set of tabs that is visually displayed at one place is distributed across multiple tiddlers.

With the part feature you can put the complete definition in one tiddler, making it easier to keep an overview and maintain the tab sets.

Example
The standard tabs at the sidebar are defined by the following eight tiddlers:

Instead of these eight tiddlers one could define the following SideBarTabs tiddler that uses the part feature:

<<tabs txtMainTab 
    Timeline Timeline SideBarTabs/Timeline 
    All 'All tiddlers' SideBarTabs/All 
    Tags 'All tags' SideBarTabs/Tags 
    More 'More lists' SideBarTabs/More>>
<part Timeline hidden><<timeline>></part>
<part All hidden><<list all>></part>
<part Tags hidden><<allTags>></part>
<part More hidden><<tabs txtMoreTab 
    Missing 'Missing tiddlers' SideBarTabs/Missing 
    Orphans 'Orphaned tiddlers' SideBarTabs/Orphans 
    Shadowed 'Shadowed tiddlers' SideBarTabs/Shadowed>></part>
<part Missing hidden><<list missing>></part>
<part Orphans hidden><<list orphans>></part>
<part Shadowed hidden><<list shadowed>></part>

Notice that you can easily "overwrite" individual parts in separate tiddlers that have the full name of the part.

E.g. if you don't like the classic timeline tab but only want to see the 100 most recent tiddlers you could create a tiddler "SideBarTabs/Timeline" with the following content:

<<forEachTiddler 
		sortBy 'tiddler.modified' descending 
		write '(index < 100) ? "* [["+tiddler.title+"]]\n":""'>>

_[Top]

Using Sliders

Very similar to the build-in <<tabs ...>> macro (see above) the <<slider ...>> macro requires that you defined an additional tiddler that holds the content "to be slid". You can avoid creating this extra tiddler by using the part feature

Example
In a tiddler "About" we may use the slider to show some details that are documented in the tiddler's "Details" part.

...
<<slider chkAboutDetails About/Details details "Click here to see more details">>
<part Details hidden>
To give you a better overview ...
</part>
...

Notice that putting the content of the slider into the slider's tiddler also has an extra benefit: When you decide you need to edit the content of the slider you can just doubleclick the content, the tiddler opens for editing and you can directly start editing the content (in the part section). In the "old" approach you would doubleclick the tiddler, see that the slider is using tiddler X, have to look for the tiddler X and can finally open it for editing. So using the part approach results in a much short workflow.

_[Top]

Revision history

v1.0.10 (2011-05-23)
- Adapt to TW 2.6.2 default behaviour when existing tiddlers are opened (don't select text) and fixed Firefox 4 issue. Thanks to dave for reporting the issue.
v1.0.9 (2007-07-14)
- Bugfix: Error when using the SideBarTabs example and switching between "More" and "Shadow". Thanks to cmari for reporting the issue.
v1.0.8 (2007-06-16)
- Speeding up display of tiddlers containing multiple pard definitions. Thanks to Paco Rivi�re for reporting the issue.
- Support "./partName" syntax inside <<tabs ...>> macro
v1.0.7 (2007-03-07)
- Bugfix: does not always render correctly after a refresh (e.g. like it happens when using the "Include" plugin). Thanks to Morris Gray for reporting the bug.
v1.0.6 (2006-11-07)
- Bugfix: cannot edit tiddler when UploadPlugin by Bidix is installed. Thanks to Jos� Luis Gonz�lez Castro for reporting the bug.
v1.0.5 (2006-03-02)
- Bugfix: Example with multi-line table cells does not work in IE6. Thanks to Paulo Soares for reporting the bug.
v1.0.4 (2006-02-28)
- Bugfix: Shadow tiddlers cannot be edited (in TW 2.0.6). Thanks to Torsten Vanek for reporting the bug.
v1.0.3 (2006-02-26)
- Adapt code to newly introduced Tiddler.prototype.isReadOnly() function (in TW 2.0.6). Thanks to Paulo Soares for reporting the problem.
v1.0.2 (2006-02-05)
- Also allow other macros than the "tiddler" macro use the "." in the part reference (to refer to "this" tiddler)
v1.0.1 (2006-01-27)
- Added Table of Content for plugin documentation. Thanks to RichCarrillo for suggesting.
- Bugfix: newReminder plugin does not work when PartTiddler is installed. Thanks to PauloSoares for reporting.
v1.0.0 (2006-01-25)
- initial version

_[Top]

Code

_[Top]

//============================================================================
//                           PartTiddlerPlugin

// Ensure that the PartTiddler Plugin is only installed once.
//
if (!version.extensions.PartTiddlerPlugin) {



version.extensions.PartTiddlerPlugin = {
    major: 1, minor: 0, revision: 10,
    date: new Date(2011, 4, 23), 
    type: 'plugin',
    source: "http://tiddlywiki.abego-software.de/#PartTiddlerPlugin"
};

if (!window.abego) window.abego = {};
if (version.major < 2) alertAndThrow("PartTiddlerPlugin requires TiddlyWiki 2.0 or newer.");

//============================================================================
// Common Helpers

// Looks for the next newline, starting at the index-th char of text. 
//
// If there are only whitespaces between index and the newline 
// the index behind the newline is returned, 
// otherwise (or when no newline is found) index is returned.
//
var skipEmptyEndOfLine = function(text, index) {
	var re = /(\n|[^\s])/g;
	re.lastIndex = index;
	var result = re.exec(text);
	return (result && text.charAt(result.index) == '\n') 
			? result.index+1
			: index;
}


//============================================================================
// Constants

var partEndOrStartTagRE = /(<\/part>)|(<part(?:\s+)((?:[^>])+)>)/mg;
var partEndTagREString = "<\\/part>";
var partEndTagString = "</part>";

//============================================================================
// Plugin Specific Helpers

// Parse the parameters inside a <part ...> tag and return the result.
//
// @return [may be null] {partName: ..., isHidden: ...}
//
var parseStartTagParams = function(paramText) {
	var params = paramText.readMacroParams();
	if (params.length == 0 || params[0].length == 0) return null;
	
	var name = params[0];
	var paramsIndex = 1;
	var hidden = false;
	if (paramsIndex < params.length) {
		hidden = params[paramsIndex] == "hidden";
		paramsIndex++;
	}
	
	return {
		partName: name, 
		isHidden: hidden
	};
}

// Returns the match to the next (end or start) part tag in the text, 
// starting the search at startIndex.
// 
// When no such tag is found null is returned, otherwise a "Match" is returned:
// [0]: full match
// [1]: matched "end" tag (or null when no end tag match)
// [2]: matched "start" tag (or null when no start tag match)
// [3]: content of start tag (or null if no start tag match)
//
var findNextPartEndOrStartTagMatch = function(text, startIndex) {
	var re = new RegExp(partEndOrStartTagRE);
	re.lastIndex = startIndex;
	var match = re.exec(text);
	return match;
}

//============================================================================
// Formatter

// Process the <part ...> ... </part> starting at (w.source, w.matchStart) for formatting.
//
// @return true if a complete part section (including the end tag) could be processed, false otherwise.
//
var handlePartSection = function(w) {
	var tagMatch = findNextPartEndOrStartTagMatch(w.source, w.matchStart);
	if (!tagMatch) return false;
	if (tagMatch.index != w.matchStart || !tagMatch[2]) return false;

	// Parse the start tag parameters
	var arguments = parseStartTagParams(tagMatch[3]);
	if (!arguments) return false;
	
	// Continue processing
	var startTagEndIndex = skipEmptyEndOfLine(w.source, tagMatch.index + tagMatch[0].length);
	var endMatch = findNextPartEndOrStartTagMatch(w.source, startTagEndIndex);
	if (endMatch && endMatch[1]) {
		if (!arguments.isHidden) {
			w.nextMatch = startTagEndIndex;
			w.subWikify(w.output,partEndTagREString);
		}
		w.nextMatch = skipEmptyEndOfLine(w.source, endMatch.index + endMatch[0].length);
		
		return true;
	}
	return false;
}

config.formatters.push( {
    name: "part",
    match: "<part\\s+[^>]+>",
	
	handler: function(w) {
		if (!handlePartSection(w)) {
			w.outputText(w.output,w.matchStart,w.matchStart+w.matchLength);
		}
	}
} )

//============================================================================
// Extend "fetchTiddler" functionality to also recognize "part"s of tiddlers 
// as tiddlers.

var currentParent = null; // used for the "." parent (e.g. in the "tiddler" macro)

// Return the match to the first <part ...> tag of the text that has the
// requrest partName.
//
// @return [may be null]
//
var findPartStartTagByName = function(text, partName) {
	var i = 0;
	
	while (true) {
		var tagMatch = findNextPartEndOrStartTagMatch(text, i);
		if (!tagMatch) return null;

		if (tagMatch[2]) {
			// Is start tag
	
			// Check the name
			var arguments = parseStartTagParams(tagMatch[3]);
			if (arguments && arguments.partName == partName) {
				return tagMatch;
			}
		}
		i = tagMatch.index+tagMatch[0].length;
	}
}

// Return the part "partName" of the given parentTiddler as a "readOnly" Tiddler 
// object, using fullName as the Tiddler's title. 
//
// All remaining properties of the new Tiddler (tags etc.) are inherited from 
// the parentTiddler.
// 
// @return [may be null]
//
var getPart = function(parentTiddler, partName, fullName) {
	var text = parentTiddler.text;
	var startTag = findPartStartTagByName(text, partName);
	if (!startTag) return null;
	
	var endIndexOfStartTag = skipEmptyEndOfLine(text, startTag.index+startTag[0].length);
	var indexOfEndTag = text.indexOf(partEndTagString, endIndexOfStartTag);

	if (indexOfEndTag >= 0) {
		var partTiddlerText = text.substring(endIndexOfStartTag,indexOfEndTag);
		var partTiddler = new Tiddler();
		partTiddler.set(
						fullName,
						partTiddlerText,
						parentTiddler.modifier,
						parentTiddler.modified,
						parentTiddler.tags,
						parentTiddler.created);
		partTiddler.abegoIsPartTiddler = true;
		return partTiddler;
	}
	
	return null;
}

// Hijack the store.fetchTiddler to recognize the "part" addresses.
//
var hijackFetchTiddler = function() {
	var oldFetchTiddler = store.fetchTiddler ;
	store.fetchTiddler = function(title) {
		var result = oldFetchTiddler.apply(this, arguments);
		if (!result && title) {
			var i = title.lastIndexOf('/');
			if (i > 0) {
				var parentName = title.substring(0, i);
				var partName = title.substring(i+1);
				var parent = (parentName == ".") 
						? store.resolveTiddler(currentParent)
						: oldFetchTiddler.apply(this, [parentName]);
				if (parent) {
					return getPart(parent, partName, parent.title+"/"+partName);
				}
			}
		}
		return result;	
	};
};

// for debugging the plugin is not loaded through the systemConfig mechanism but via a script tag. 
// At that point in the "store" is not yet defined. In that case hijackFetchTiddler through the restart function.
// Otherwise hijack now.
if (!store) {
	var oldRestartFunc = restart;
	window.restart = function() {
		hijackFetchTiddler();
		oldRestartFunc.apply(this,arguments);
	};
} else
	hijackFetchTiddler();




// The user must not edit a readOnly/partTiddler
//

config.commands.editTiddler.oldIsReadOnlyFunction = Tiddler.prototype.isReadOnly;

Tiddler.prototype.isReadOnly = function() {
	// Tiddler.isReadOnly was introduced with TW 2.0.6.
	// For older version we explicitly check the global readOnly flag
	if (config.commands.editTiddler.oldIsReadOnlyFunction) {
		if (config.commands.editTiddler.oldIsReadOnlyFunction.apply(this, arguments)) return true;
	} else {
		if (readOnly) return true;
	}

	return this.abegoIsPartTiddler;
}

config.commands.editTiddler.handler_PartTiddlerPlugin = config.commands.editTiddler.handler;

config.commands.editTiddler.handler = function(event,src,title)
{
	var t = store.getTiddler(title);
	// Edit the tiddler if it either is not a tiddler (but a shadowTiddler)
	// or the tiddler is not readOnly
	if(!t || !t.abegoIsPartTiddler)
		{
		return config.commands.editTiddler.handler_PartTiddlerPlugin(event,src,title);
		}
	return false;
}

// To allow the "./partName" syntax in macros we need to hijack 
// the invokeMacro to define the "currentParent" while it is running.
// 
var oldInvokeMacro = window.invokeMacro;
function myInvokeMacro(place,macro,params,wikifier,tiddler) {
	var oldCurrentParent = currentParent;
	if (tiddler) currentParent = tiddler;
	try {
		oldInvokeMacro.apply(this, arguments);
	} finally {
		currentParent = oldCurrentParent;
	}
}
window.invokeMacro = myInvokeMacro;

// To correctly support the "./partName" syntax while refreshing we need to hijack 
// the config.refreshers.tiddlers to define the "currentParent" while it is running.
// 
(function() {
	var oldTiddlerRefresher= config.refreshers.tiddler;
	config.refreshers.tiddler = function(e,changeList) {
		var oldCurrentParent = currentParent;
		try {
			currentParent = e.getAttribute("tiddler");
			return oldTiddlerRefresher.apply(this,arguments);
		} finally {
			currentParent = oldCurrentParent;
		}
	};
})();

// Support "./partName" syntax inside <<tabs ...>> macro
(function() {
	var extendRelativeNames = function(e, title) {
		var nodes = e.getElementsByTagName("a");
		for(var i=0; i<nodes.length; i++) {
			var node = nodes[i];
			var s = node.getAttribute("content");
			if (s && s.indexOf("./") == 0)
				node.setAttribute("content",title+s.substr(1));
		}
	};
	var oldHandler = config.macros.tabs.handler;
	config.macros.tabs.handler = function(place,macroName,params,wikifier,paramString,tiddler) {
		var result = oldHandler.apply(this,arguments);
		if (tiddler)
			extendRelativeNames(place, tiddler.title);
		return result;
	};
})();

// Scroll the anchor anchorName in the viewer of the given tiddler visible.
// When no tiddler is defined use the tiddler of the target given event is used.
window.scrollAnchorVisible = function(anchorName, tiddler, evt) {
	var tiddlerElem = null;
	if (tiddler) {
		tiddlerElem = document.getElementById(story.idPrefix + tiddler);
	}
	if (!tiddlerElem && evt) {
		var target = resolveTarget(evt);
		tiddlerElem = story.findContainingTiddler(target);
	}
	if (!tiddlerElem) return;

	var children = tiddlerElem.getElementsByTagName("a");
	for (var i = 0; i < children.length; i++) {
		var child = children[i];
		var name = child.getAttribute("name");
		if (name == anchorName) {
			var y = findPosY(child);
			window.scrollTo(0,y);
			return;
		}
	}
}

} // of "install only once"

_[Top]

Licence and Copyright

Copyright (c) abego Software GmbH, 2011 (www.abego-software.de)

Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.

Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or other
materials provided with the distribution.

Neither the name of abego Software nor the names of its contributors may be
used to endorse or promote products derived from this software without specific
prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.

_[Top]

IntelliTaggerPlugin

Mon, 16 Apr 2012 21:38:00 GMT

Name:	IntelliTaggerPlugin
Version:	1.0.2 (2007-07-25)
Type:	plugin
Source:	http://tiddlywiki.abego-software.de/#IntelliTaggerPlugin
Author:	Udo Borkowski (ub [at] abego-software [dot] de)
Documentation:	IntelliTaggerPlugin Documentation
SourceCode:	IntelliTaggerPlugin SourceCode
Licence:	BSD open source license (abego Software)
CoreVersion:	2.0.8
Browser:	Firefox 1.5.0.2 or better

Version History

1.0.2 (2007-07-25):
- Feature: "Return" key may be used to accept first tag suggestion (beside "Alt-1")
- Bugfix: Keyboard shortcuts (Alt+3 etc.) shifted
1.0.1 (2007-05-18):
- Improvement: Speedup when using TiddlyWikis with many tags
1.0.0 (2006-04-26):
- Initial release

Source Code

ForEachTiddlerPlugin

Mon, 16 Apr 2012 21:38:00 GMT

Name:	ForEachTiddlerPlugin
Version:	1.0.8 (2007-04-12)
Source:	http://tiddlywiki.abego-software.de/#ForEachTiddlerPlugin
Author:	UdoBorkowski (ub [at] abego-software [dot] de)
Licence:	BSD open source license (abego Software)
Copyright:	© 2005-2007 abego Software
TiddlyWiki:	1.2.38+, 2.0
Browser:	Firefox 1.0.4+; Firefox 1.5; InternetExplorer 6.0

Description

Create customizable lists, tables etc. for your selections of tiddlers. Specify the tiddlers to include and their order through a powerful language.

Syntax:

`<<`forEachTiddler [in tiddlyWikiPath] [where whereCondition] [sortBy sortExpression [ascending or descending]] [script scriptText] [action [actionParameters]]`>>`
tiddlyWikiPath	The filepath to the TiddlyWiki the macro should work on. When missing the current TiddlyWiki is used.
whereCondition	(quoted) JavaScript boolean expression. May refer to the build-in variables `tiddler` and `context`.
sortExpression	(quoted) JavaScript expression returning "comparable" objects (using '`<`','`>`','`==`'. May refer to the build-in variables `tiddler` and `context`.
scriptText	(quoted) JavaScript text. Typically defines JavaScript functions that are called by the various JavaScript expressions (whereClause, sortClause, action arguments,...)
action	The action that should be performed on every selected tiddler, in the given order. By default the actions addToList and write are supported. When no action is specified addToList is used.
actionParameters	(action specific) parameters the action may refer while processing the tiddlers (see action descriptions for details). JavaScript in actionParameters may refer to the build-in variables `tiddler`, `count`, `index` and `context`.
_{Syntax formatting: Keywords in bold, optional parts in [...]. 'or' means that exactly one of the two alternatives must exist.}

See details see ForEachTiddlerMacro and ForEachTiddlerExamples.

Revision history

v1.0.8 (2007-04-12)
- Adapted to latest TiddlyWiki 2.2 Beta importTiddlyWiki API (introduced with changeset 2004). TiddlyWiki 2.2 Beta builds prior to changeset 2004 are no longer supported (but TiddlyWiki 2.1 and earlier, of cause)
v1.0.7 (2007-03-28)
- Also support "pre" formatted TiddlyWikis (introduced with TW 2.2) (when using "in" clause to work on external tiddlers)
v1.0.6 (2006-09-16)
- Context provides "viewerTiddler", i.e. the tiddler used to view the macro. Most times this is equal to the "inTiddler", but when using the "tiddler" macro both may be different.
- Support "begin", "end" and "none" expressions in "write" action
v1.0.5 (2006-02-05)
- Pass tiddler containing the macro with wikify, context object also holds reference to tiddler containing the macro ("inTiddler"). Thanks to SimonBaird.
- Support Firefox 1.5.0.1
- Internal
  - Make "JSLint" conform
  - "Only install once"
v1.0.4 (2006-01-06)
- Support TiddlyWiki 2.0
v1.0.3 (2005-12-22)
- Features:
  - Write output to a file supports multi-byte environments (Thanks to Bram Chen)
  - Provide API to access the forEachTiddler functionality directly through JavaScript (see getTiddlers and performMacro)
- Enhancements:
  - Improved error messages on InternetExplorer.
v1.0.2 (2005-12-10)
- Features:
  - context object also holds reference to store (TiddlyWiki)
- Fixed Bugs:
  - ForEachTiddler 1.0.1 has broken support on win32 Opera 8.51 (Thanks to BrunoSabin for reporting)
v1.0.1 (2005-12-08)
- Features:
  - Access tiddlers stored in separated TiddlyWikis through the "in" option. I.e. you are no longer limited to only work on the "current TiddlyWiki".
  - Write output to an external file using the "toFile" option of the "write" action. With this option you may write your customized tiddler exports.
  - Use the "script" section to define "helper" JavaScript functions etc. to be used in the various JavaScript expressions (whereClause, sortClause, action arguments,...).
  - Access and store context information for the current forEachTiddler invocation (through the build-in "context" object) .
  - Improved script evaluation (for where/sort clause and write scripts).
v1.0.0 (2005-11-20)
- initial version

Code

	
//============================================================================
//============================================================================
//		   ForEachTiddlerPlugin
//============================================================================
//============================================================================

// Only install once
if (!version.extensions.ForEachTiddlerPlugin) {

if (!window.abego) window.abego = {};

version.extensions.ForEachTiddlerPlugin = {
	major: 1, minor: 0, revision: 8, 
	date: new Date(2007,3,12), 
	source: "http://tiddlywiki.abego-software.de/#ForEachTiddlerPlugin",
	licence: "[[BSD open source license (abego Software)|http://www.abego-software.de/legal/apl-v10.html]]",
	copyright: "Copyright (c) abego Software GmbH, 2005-2007 (www.abego-software.de)"
};

// For backward compatibility with TW 1.2.x
//
if (!TiddlyWiki.prototype.forEachTiddler) {
	TiddlyWiki.prototype.forEachTiddler = function(callback) {
		for(var t in this.tiddlers) {
			callback.call(this,t,this.tiddlers[t]);
		}
	};
}

//============================================================================
// forEachTiddler Macro
//============================================================================

version.extensions.forEachTiddler = {
	major: 1, minor: 0, revision: 8, date: new Date(2007,3,12), provider: "http://tiddlywiki.abego-software.de"};

// ---------------------------------------------------------------------------
// Configurations and constants 
// ---------------------------------------------------------------------------

config.macros.forEachTiddler = {
	 // Standard Properties
	 label: "forEachTiddler",
	 prompt: "Perform actions on a (sorted) selection of tiddlers",

	 // actions
	 actions: {
		 addToList: {},
		 write: {}
	 }
};

// ---------------------------------------------------------------------------
//  The forEachTiddler Macro Handler 
// ---------------------------------------------------------------------------

config.macros.forEachTiddler.getContainingTiddler = function(e) {
	while(e && !hasClass(e,"tiddler"))
		e = e.parentNode;
	var title = e ? e.getAttribute("tiddler") : null; 
	return title ? store.getTiddler(title) : null;
};

config.macros.forEachTiddler.handler = function(place,macroName,params,wikifier,paramString,tiddler) {
	// config.macros.forEachTiddler.traceMacroCall(place,macroName,params,wikifier,paramString,tiddler);

	if (!tiddler) tiddler = config.macros.forEachTiddler.getContainingTiddler(place);
	// --- Parsing ------------------------------------------

	var i = 0; // index running over the params
	// Parse the "in" clause
	var tiddlyWikiPath = undefined;
	if ((i < params.length) && params[i] == "in") {
		i++;
		if (i >= params.length) {
			this.handleError(place, "TiddlyWiki path expected behind 'in'.");
			return;
		}
		tiddlyWikiPath = this.paramEncode((i < params.length) ? params[i] : "");
		i++;
	}

	// Parse the where clause
	var whereClause ="true";
	if ((i < params.length) && params[i] == "where") {
		i++;
		whereClause = this.paramEncode((i < params.length) ? params[i] : "");
		i++;
	}

	// Parse the sort stuff
	var sortClause = null;
	var sortAscending = true; 
	if ((i < params.length) && params[i] == "sortBy") {
		i++;
		if (i >= params.length) {
			this.handleError(place, "sortClause missing behind 'sortBy'.");
			return;
		}
		sortClause = this.paramEncode(params[i]);
		i++;

		if ((i < params.length) && (params[i] == "ascending" || params[i] == "descending")) {
			 sortAscending = params[i] == "ascending";
			 i++;
		}
	}

	// Parse the script
	var scriptText = null;
	if ((i < params.length) && params[i] == "script") {
		i++;
		scriptText = this.paramEncode((i < params.length) ? params[i] : "");
		i++;
	}

	// Parse the action. 
	// When we are already at the end use the default action
	var actionName = "addToList";
	if (i < params.length) {
	   if (!config.macros.forEachTiddler.actions[params[i]]) {
			this.handleError(place, "Unknown action '"+params[i]+"'.");
			return;
		} else {
			actionName = params[i]; 
			i++;
		}
	} 
	
	// Get the action parameter
	// (the parsing is done inside the individual action implementation.)
	var actionParameter = params.slice(i);


	// --- Processing ------------------------------------------
	try {
		this.performMacro({
				place: place, 
				inTiddler: tiddler,
				whereClause: whereClause, 
				sortClause: sortClause, 
				sortAscending: sortAscending, 
				actionName: actionName, 
				actionParameter: actionParameter, 
				scriptText: scriptText, 
				tiddlyWikiPath: tiddlyWikiPath});

	} catch (e) {
		this.handleError(place, e);
	}
};

// Returns an object with properties "tiddlers" and "context".
// tiddlers holds the (sorted) tiddlers selected by the parameter,
// context the context of the execution of the macro.
//
// The action is not yet performed.
//
// @parameter see performMacro
//
config.macros.forEachTiddler.getTiddlersAndContext = function(parameter) {

	var context = config.macros.forEachTiddler.createContext(parameter.place, parameter.whereClause, parameter.sortClause, parameter.sortAscending, parameter.actionName, parameter.actionParameter, parameter.scriptText, parameter.tiddlyWikiPath, parameter.inTiddler);

	var tiddlyWiki = parameter.tiddlyWikiPath ? this.loadTiddlyWiki(parameter.tiddlyWikiPath) : store;
	context["tiddlyWiki"] = tiddlyWiki;
	
	// Get the tiddlers, as defined by the whereClause
	var tiddlers = this.findTiddlers(parameter.whereClause, context, tiddlyWiki);
	context["tiddlers"] = tiddlers;

	// Sort the tiddlers, when sorting is required.
	if (parameter.sortClause) {
		this.sortTiddlers(tiddlers, parameter.sortClause, parameter.sortAscending, context);
	}

	return {tiddlers: tiddlers, context: context};
};

// Returns the (sorted) tiddlers selected by the parameter.
//
// The action is not yet performed.
//
// @parameter see performMacro
//
config.macros.forEachTiddler.getTiddlers = function(parameter) {
	return this.getTiddlersAndContext(parameter).tiddlers;
};

// Performs the macros with the given parameter.
//
// @param parameter holds the parameter of the macro as separate properties.
//				  The following properties are supported:
//
//						place
//						whereClause
//						sortClause
//						sortAscending
//						actionName
//						actionParameter
//						scriptText
//						tiddlyWikiPath
//
//					All properties are optional. 
//					For most actions the place property must be defined.
//
config.macros.forEachTiddler.performMacro = function(parameter) {
	var tiddlersAndContext = this.getTiddlersAndContext(parameter);

	// Perform the action
	var actionName = parameter.actionName ? parameter.actionName : "addToList";
	var action = config.macros.forEachTiddler.actions[actionName];
	if (!action) {
		this.handleError(parameter.place, "Unknown action '"+actionName+"'.");
		return;
	}

	var actionHandler = action.handler;
	actionHandler(parameter.place, tiddlersAndContext.tiddlers, parameter.actionParameter, tiddlersAndContext.context);
};

// ---------------------------------------------------------------------------
//  The actions 
// ---------------------------------------------------------------------------

// Internal.
//
// --- The addToList Action -----------------------------------------------
//
config.macros.forEachTiddler.actions.addToList.handler = function(place, tiddlers, parameter, context) {
	// Parse the parameter
	var p = 0;

	// Check for extra parameters
	if (parameter.length > p) {
		config.macros.forEachTiddler.createExtraParameterErrorElement(place, "addToList", parameter, p);
		return;
	}

	// Perform the action.
	var list = document.createElement("ul");
	place.appendChild(list);
	for (var i = 0; i < tiddlers.length; i++) {
		var tiddler = tiddlers[i];
		var listItem = document.createElement("li");
		list.appendChild(listItem);
		createTiddlyLink(listItem, tiddler.title, true);
	}
};

abego.parseNamedParameter = function(name, parameter, i) {
	var beginExpression = null;
	if ((i < parameter.length) && parameter[i] == name) {
		i++;
		if (i >= parameter.length) {
			throw "Missing text behind '%0'".format([name]);
		}
		
		return config.macros.forEachTiddler.paramEncode(parameter[i]);
	}
	return null;
}

// Internal.
//
// --- The write Action ---------------------------------------------------
//
config.macros.forEachTiddler.actions.write.handler = function(place, tiddlers, parameter, context) {
	// Parse the parameter
	var p = 0;
	if (p >= parameter.length) {
		this.handleError(place, "Missing expression behind 'write'.");
		return;
	}

	var textExpression = config.macros.forEachTiddler.paramEncode(parameter[p]);
	p++;

	// Parse the "begin" option
	var beginExpression = abego.parseNamedParameter("begin", parameter, p);
	if (beginExpression !== null) 
		p += 2;
	var endExpression = abego.parseNamedParameter("end", parameter, p);
	if (endExpression !== null) 
		p += 2;
	var noneExpression = abego.parseNamedParameter("none", parameter, p);
	if (noneExpression !== null) 
		p += 2;

	// Parse the "toFile" option
	var filename = null;
	var lineSeparator = undefined;
	if ((p < parameter.length) && parameter[p] == "toFile") {
		p++;
		if (p >= parameter.length) {
			this.handleError(place, "Filename expected behind 'toFile' of 'write' action.");
			return;
		}
		
		filename = config.macros.forEachTiddler.getLocalPath(config.macros.forEachTiddler.paramEncode(parameter[p]));
		p++;
		if ((p < parameter.length) && parameter[p] == "withLineSeparator") {
			p++;
			if (p >= parameter.length) {
				this.handleError(place, "Line separator text expected behind 'withLineSeparator' of 'write' action.");
				return;
			}
			lineSeparator = config.macros.forEachTiddler.paramEncode(parameter[p]);
			p++;
		}
	}
	
	// Check for extra parameters
	if (parameter.length > p) {
		config.macros.forEachTiddler.createExtraParameterErrorElement(place, "write", parameter, p);
		return;
	}

	// Perform the action.
	var func = config.macros.forEachTiddler.getEvalTiddlerFunction(textExpression, context);
	var count = tiddlers.length;
	var text = "";
	if (count > 0 && beginExpression)
		text += config.macros.forEachTiddler.getEvalTiddlerFunction(beginExpression, context)(undefined, context, count, undefined);
	
	for (var i = 0; i < count; i++) {
		var tiddler = tiddlers[i];
		text += func(tiddler, context, count, i);
	}
	
	if (count > 0 && endExpression)
		text += config.macros.forEachTiddler.getEvalTiddlerFunction(endExpression, context)(undefined, context, count, undefined);

	if (count == 0 && noneExpression) 
		text += config.macros.forEachTiddler.getEvalTiddlerFunction(noneExpression, context)(undefined, context, count, undefined);
		

	if (filename) {
		if (lineSeparator !== undefined) {
			lineSeparator = lineSeparator.replace(/\\n/mg, "\n").replace(/\\r/mg, "\r");
			text = text.replace(/\n/mg,lineSeparator);
		}
		saveFile(filename, convertUnicodeToUTF8(text));
	} else {
		var wrapper = createTiddlyElement(place, "span");
		wikify(text, wrapper, null/* highlightRegExp */, context.inTiddler);
	}
};


// ---------------------------------------------------------------------------
//  Helpers
// ---------------------------------------------------------------------------

// Internal.
//
config.macros.forEachTiddler.createContext = function(placeParam, whereClauseParam, sortClauseParam, sortAscendingParam, actionNameParam, actionParameterParam, scriptText, tiddlyWikiPathParam, inTiddlerParam) {
	return {
		place : placeParam, 
		whereClause : whereClauseParam, 
		sortClause : sortClauseParam, 
		sortAscending : sortAscendingParam, 
		script : scriptText,
		actionName : actionNameParam, 
		actionParameter : actionParameterParam,
		tiddlyWikiPath : tiddlyWikiPathParam,
		inTiddler : inTiddlerParam, // the tiddler containing the <<forEachTiddler ...>> macro call.
		viewerTiddler : config.macros.forEachTiddler.getContainingTiddler(placeParam) // the tiddler showing the forEachTiddler result
	};
};

// Internal.
//
// Returns a TiddlyWiki with the tiddlers loaded from the TiddlyWiki of 
// the given path.
//
config.macros.forEachTiddler.loadTiddlyWiki = function(path, idPrefix) {
	if (!idPrefix) {
		idPrefix = "store";
	}
	var lenPrefix = idPrefix.length;
	
	// Read the content of the given file
	var content = loadFile(this.getLocalPath(path));
	if(content === null) {
		throw "TiddlyWiki '"+path+"' not found.";
	}
	
	var tiddlyWiki = new TiddlyWiki();

	// Starting with TW 2.2 there is a helper function to import the tiddlers
	if (tiddlyWiki.importTiddlyWiki) {
		if (!tiddlyWiki.importTiddlyWiki(content))
			throw "File '"+path+"' is not a TiddlyWiki.";
		tiddlyWiki.dirty = false;
		return tiddlyWiki;
	}
	
	// The legacy code, for TW < 2.2
	
	// Locate the storeArea div's
	var posOpeningDiv = content.indexOf(startSaveArea);
	var posClosingDiv = content.lastIndexOf(endSaveArea);
	if((posOpeningDiv == -1) || (posClosingDiv == -1)) {
		throw "File '"+path+"' is not a TiddlyWiki.";
	}
	var storageText = content.substr(posOpeningDiv + startSaveArea.length, posClosingDiv);
	
	// Create a "div" element that contains the storage text
	var myStorageDiv = document.createElement("div");
	myStorageDiv.innerHTML = storageText;
	myStorageDiv.normalize();
	
	// Create all tiddlers in a new TiddlyWiki
	// (following code is modified copy of TiddlyWiki.prototype.loadFromDiv)
	var store = myStorageDiv.childNodes;
	for(var t = 0; t < store.length; t++) {
		var e = store[t];
		var title = null;
		if(e.getAttribute)
			title = e.getAttribute("tiddler");
		if(!title && e.id && e.id.substr(0,lenPrefix) == idPrefix)
			title = e.id.substr(lenPrefix);
		if(title && title !== "") {
			var tiddler = tiddlyWiki.createTiddler(title);
			tiddler.loadFromDiv(e,title);
		}
	}
	tiddlyWiki.dirty = false;

	return tiddlyWiki;
};


	
// Internal.
//
// Returns a function that has a function body returning the given javaScriptExpression.
// The function has the parameters:
// 
//	 (tiddler, context, count, index)
//
config.macros.forEachTiddler.getEvalTiddlerFunction = function (javaScriptExpression, context) {
	var script = context["script"];
	var functionText = "var theFunction = function(tiddler, context, count, index) { return "+javaScriptExpression+"}";
	var fullText = (script ? script+";" : "")+functionText+";theFunction;";
	return eval(fullText);
};

// Internal.
//
config.macros.forEachTiddler.findTiddlers = function(whereClause, context, tiddlyWiki) {
	var result = [];
	var func = config.macros.forEachTiddler.getEvalTiddlerFunction(whereClause, context);
	tiddlyWiki.forEachTiddler(function(title,tiddler) {
		if (func(tiddler, context, undefined, undefined)) {
			result.push(tiddler);
		}
	});
	return result;
};

// Internal.
//
config.macros.forEachTiddler.createExtraParameterErrorElement = function(place, actionName, parameter, firstUnusedIndex) {
	var message = "Extra parameter behind '"+actionName+"':";
	for (var i = firstUnusedIndex; i < parameter.length; i++) {
		message += " "+parameter[i];
	}
	this.handleError(place, message);
};

// Internal.
//
config.macros.forEachTiddler.sortAscending = function(tiddlerA, tiddlerB) {
	var result = 
		(tiddlerA.forEachTiddlerSortValue == tiddlerB.forEachTiddlerSortValue) 
			? 0
			: (tiddlerA.forEachTiddlerSortValue < tiddlerB.forEachTiddlerSortValue)
			   ? -1 
			   : +1; 
	return result;
};

// Internal.
//
config.macros.forEachTiddler.sortDescending = function(tiddlerA, tiddlerB) {
	var result = 
		(tiddlerA.forEachTiddlerSortValue == tiddlerB.forEachTiddlerSortValue) 
			? 0
			: (tiddlerA.forEachTiddlerSortValue < tiddlerB.forEachTiddlerSortValue)
			   ? +1 
			   : -1; 
	return result;
};

// Internal.
//
config.macros.forEachTiddler.sortTiddlers = function(tiddlers, sortClause, ascending, context) {
	// To avoid evaluating the sortClause whenever two items are compared 
	// we pre-calculate the sortValue for every item in the array and store it in a 
	// temporary property ("forEachTiddlerSortValue") of the tiddlers.
	var func = config.macros.forEachTiddler.getEvalTiddlerFunction(sortClause, context);
	var count = tiddlers.length;
	var i;
	for (i = 0; i < count; i++) {
		var tiddler = tiddlers[i];
		tiddler.forEachTiddlerSortValue = func(tiddler,context, undefined, undefined);
	}

	// Do the sorting
	tiddlers.sort(ascending ? this.sortAscending : this.sortDescending);

	// Delete the temporary property that holds the sortValue.	
	for (i = 0; i < tiddlers.length; i++) {
		delete tiddlers[i].forEachTiddlerSortValue;
	}
};


// Internal.
//
config.macros.forEachTiddler.trace = function(message) {
	displayMessage(message);
};

// Internal.
//
config.macros.forEachTiddler.traceMacroCall = function(place,macroName,params) {
	var message ="<<"+macroName;
	for (var i = 0; i < params.length; i++) {
		message += " "+params[i];
	}
	message += ">>";
	displayMessage(message);
};


// Internal.
//
// Creates an element that holds an error message
// 
config.macros.forEachTiddler.createErrorElement = function(place, exception) {
	var message = (exception.description) ? exception.description : exception.toString();
	return createTiddlyElement(place,"span",null,"forEachTiddlerError","<<forEachTiddler ...>>: "+message);
};

// Internal.
//
// @param place [may be null]
//
config.macros.forEachTiddler.handleError = function(place, exception) {
	if (place) {
		this.createErrorElement(place, exception);
	} else {
		throw exception;
	}
};

// Internal.
//
// Encodes the given string.
//
// Replaces 
//	 "$))" to ">>"
//	 "$)" to ">"
//
config.macros.forEachTiddler.paramEncode = function(s) {
	var reGTGT = new RegExp("\\$\\)\\)","mg");
	var reGT = new RegExp("\\$\\)","mg");
	return s.replace(reGTGT, ">>").replace(reGT, ">");
};

// Internal.
//
// Returns the given original path (that is a file path, starting with "file:")
// as a path to a local file, in the systems native file format.
//
// Location information in the originalPath (i.e. the "#" and stuff following)
// is stripped.
// 
config.macros.forEachTiddler.getLocalPath = function(originalPath) {
	// Remove any location part of the URL
	var hashPos = originalPath.indexOf("#");
	if(hashPos != -1)
		originalPath = originalPath.substr(0,hashPos);
	// Convert to a native file format assuming
	// "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;
};

// ---------------------------------------------------------------------------
// Stylesheet Extensions (may be overridden by local StyleSheet)
// ---------------------------------------------------------------------------
//
setStylesheet(
	".forEachTiddlerError{color: #ffffff;background-color: #880000;}",
	"forEachTiddler");

//============================================================================
// End of forEachTiddler Macro
//============================================================================


//============================================================================
// String.startsWith Function
//============================================================================
//
// Returns true if the string starts with the given prefix, false otherwise.
//
version.extensions["String.startsWith"] = {major: 1, minor: 0, revision: 0, date: new Date(2005,11,20), provider: "http://tiddlywiki.abego-software.de"};
//
String.prototype.startsWith = function(prefix) {
	var n =  prefix.length;
	return (this.length >= n) && (this.slice(0, n) == prefix);
};



//============================================================================
// String.endsWith Function
//============================================================================
//
// Returns true if the string ends with the given suffix, false otherwise.
//
version.extensions["String.endsWith"] = {major: 1, minor: 0, revision: 0, date: new Date(2005,11,20), provider: "http://tiddlywiki.abego-software.de"};
//
String.prototype.endsWith = function(suffix) {
	var n = suffix.length;
	return (this.length >= n) && (this.right(n) == suffix);
};


//============================================================================
// String.contains Function
//============================================================================
//
// Returns true when the string contains the given substring, false otherwise.
//
version.extensions["String.contains"] = {major: 1, minor: 0, revision: 0, date: new Date(2005,11,20), provider: "http://tiddlywiki.abego-software.de"};
//
String.prototype.contains = function(substring) {
	return this.indexOf(substring) >= 0;
};

//============================================================================
// Array.indexOf Function
//============================================================================
//
// Returns the index of the first occurance of the given item in the array or 
// -1 when no such item exists.
//
// @param item [may be null]
//
version.extensions["Array.indexOf"] = {major: 1, minor: 0, revision: 0, date: new Date(2005,11,20), provider: "http://tiddlywiki.abego-software.de"};
//
Array.prototype.indexOf = function(item) {
	for (var i = 0; i < this.length; i++) {
		if (this[i] == item) {
			return i;
		}
	}
	return -1;
};

//============================================================================
// Array.contains Function
//============================================================================
//
// Returns true when the array contains the given item, otherwise false. 
//
// @param item [may be null]
//
version.extensions["Array.contains"] = {major: 1, minor: 0, revision: 0, date: new Date(2005,11,20), provider: "http://tiddlywiki.abego-software.de"};
//
Array.prototype.contains = function(item) {
	return (this.indexOf(item) >= 0);
};

//============================================================================
// Array.containsAny Function
//============================================================================
//
// Returns true when the array contains at least one of the elements 
// of the item. Otherwise (or when items contains no elements) false is returned.
//
version.extensions["Array.containsAny"] = {major: 1, minor: 0, revision: 0, date: new Date(2005,11,20), provider: "http://tiddlywiki.abego-software.de"};
//
Array.prototype.containsAny = function(items) {
	for(var i = 0; i < items.length; i++) {
		if (this.contains(items[i])) {
			return true;
		}
	}
	return false;
};


//============================================================================
// Array.containsAll Function
//============================================================================
//
// Returns true when the array contains all the items, otherwise false.
// 
// When items is null false is returned (even if the array contains a null).
//
// @param items [may be null] 
//
version.extensions["Array.containsAll"] = {major: 1, minor: 0, revision: 0, date: new Date(2005,11,20), provider: "http://tiddlywiki.abego-software.de"};
//
Array.prototype.containsAll = function(items) {
	for(var i = 0; i < items.length; i++) {
		if (!this.contains(items[i])) {
			return false;
		}
	}
	return true;
};


} // of "install only once"

// Used Globals (for JSLint) ==============
// ... DOM
/*global 	document */
// ... TiddlyWiki Core
/*global 	convertUnicodeToUTF8, createTiddlyElement, createTiddlyLink, 
			displayMessage, endSaveArea, hasClass, loadFile, saveFile, 
			startSaveArea, store, wikify */

Licence and Copyright

Copyright (c) abego Software GmbH, 2005 (www.abego-software.de)

Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.

Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or other
materials provided with the distribution.

Neither the name of abego Software nor the names of its contributors may be
used to endorse or promote products derived from this software without specific
prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.

SyncFileTiddlers

Mon, 16 Apr 2012 21:35:00 GMT

DataTiddlerPlugin	archive/DataTiddlerPlugin/latest/DataTiddlerPlugin.js	readonly
ForEachTiddlerPlugin	archive/ForEachTiddlerPlugin/latest/ForEachTiddlerPlugin.js	readonly
FormTiddlerPlugin	archive/FormTiddlerPlugin/latest/FormTiddlerPlugin.js	readonly
IncludePlugin	archive/IncludePlugin/latest/IncludePlugin.js	readonly
IntelliTaggerPlugin	archive/IntelliTaggerPlugin/latest/IntelliTaggerPlugin.js	readonly
PartTiddlerPlugin	archive/PartTiddlerPlugin/latest/PartTiddlerPlugin.js	readonly
SettingsPlugin	archive/SettingsPlugin/latest/SettingsPlugin.js	readonly
TiddlerWithParamsPlugin	archive/TiddlerWithParamsPlugin/latest/TiddlerWithParamsPlugin.js	readonly
XHTML10Plugin	archive/XHTML10Plugin/latest/XHTML10Plugin.js	readonly
YourSearchPlugin	archive/YourSearchPlugin/latest/YourSearchPlugin.js	readonly

SyncFileTiddlerPlugin

Mon, 16 Apr 2012 21:14:00 GMT

Name:	SyncFileTiddlerPlugin
Summary:	Automatically synchronizes the text of a tiddler with the content of an associated text file.
Version:	1.0.0 (2012-04-16)
Source:	http://tiddlywiki.abego-software.de/#SyncFileTiddlerPlugin
Author:	UdoBorkowski (ub [at] abego-software [dot] de)
Licence:	BSD open source license (abego Software)
Copyright:	© 2012 abego Software

About SyncFileTiddler

SyncFileTiddler automatically synchronizes the text of a tiddler with the content of an associated text file.

The tiddlers to be synched are specified in a table in the tiddler SyncFileTiddlers. A table entry looks like this:

|SomeTiddler|path/To/File.txt|readonly|

This will be rendered as:

SomeTiddler

path/To/File.txt

readonly

When the "readonly" parameter is missing the tiddler is editable. Changes to the tiddler's text will be written to the associated file.
When "readonly" is specified the tiddler is not editable in the TiddlyWiki, but changes in the associated file will also change the tiddler's text accordingly.
The file is regularily read ("polled") to verify if its text has changed.

The tags of the tiddler can only be specified in the TiddlyWiki. The file will not affect the tags.

Revision history

SyncFileTiddlerPlugin 1.0.0 (2012-04-16)
- initial version

Source Code

var abego = abego || {};

(function(namespace) {	
	var entries = {};

	var errorMsg = function(s) {
		throw "SyncFileTiddler: " + s;
	};
	
	var save = function(filepath, s) {
		var b = saveFile(filepath, s);
		if (!b) {
			throw errorMsg("file could not be saved: " + filepath);
		}
		return s;
	};

	var createTiddler = function(title, text) {
		var t = store.createTiddler(title);
		t.text = text;
		return text;
	};

	var getTiddlerText = function(title) {
		return store.getTiddlerText(title, null);
	};

	var setTiddlerText = function(title, text) {
		var t = store.fetchTiddler(title);
		store.saveTiddler(title, title, text, "SyncFileTiddler ("
				+ config.options.txtUserName + ")", new Date(), t.fields.tags);
		return text;
	};

	/**
	 * FIXME: also implement the "delete" case, i.e. delete the "Slave" when the
	 * "Master" is missing (need a deleteFile method first). (? What about
	 * losing tags when deleting the tiddler after a file delete?)
	 * 
	 * @param oldFileContent
	 *            [nullable] when not null it holds the content of the file as
	 *            it was loaded "some time ago". Before the method overwrites
	 *            the file it checks if the file still has the oldFileContent.
	 *            If the file's current content differs from the oldFileContent,
	 *            the file was modified "from the outside". Then we have a sync
	 *            conflict and the method fails.
	 * @param fileIsMaster
	 *            when true the file is the Master, i.e. the tiddler should get
	 *            the file's content. When false the file should get the
	 *            tiddler's content. When undefined the function should try to
	 *            find out what is the Master.
	 * @return [nullable] the text/content of the Tiddler/File, or null if
	 *         neither Tiddler nor File exists
	 */
	var syncTiddlerAndFile = function(tiddler, filepath, oldFileContent,
			fileIsMaster) {
		var tiddlerContent = getTiddlerText(tiddler);
		var fileContent = loadFile(filepath);
		
		if (fileContent) {
			fileContent = fileContent.replace(/\r\n/g,'\n');
			
			if (tiddlerContent) {
				// both file and tiddler exist.

				if (fileContent == tiddlerContent) {
					// both file and tiddler are equal
					return fileContent;

				} else {
					// file and tiddler differ.
					if (fileIsMaster === undefined) {
						// No Master is explicitly defined.
						throw errorMsg("tiddler and file have different content (delete the 'old' one to fix this):\n"
								+ tiddler + "\n" + filepath);

					} else if (fileIsMaster) {
						// the file is the master, i.e. the tiddler gets the
						// file's content
						return setTiddlerText(tiddler, fileContent);

					} else {
						// the tiddler is the master, i.e. the file gets the
						// tiddler's text

						// But first check if the file was not modified in the
						// meantime
						if (oldFileContent && oldFileContent != fileContent) {
							throw errorMsg("The file was modified externally: "
									+ filepath);
						}
						return save(filepath, tiddlerContent);
					}
				}
			} else {
				// file exists, but no tiddler.

				// Create a new tiddler with the fileContent
				return createTiddler(tiddler, fileContent);
			}
		} else {
			if (tiddlerContent) {
				// tiddler exists, but no file.

				// create a file with the tiddler's content
				return save(filepath, tiddlerContent);
			} else {
				// Neither tiddler nor file exists.

				// do nothing
				return null;
			}
		}
	};

	var syncEntry = function(entry, fileIsMaster, ignoreOldFileContent) {
		if (entry.readonly && !fileIsMaster) {
			return false;
		}
		
		entry.oldFileContent = syncTiddlerAndFile(entry.tiddler,
				entry.filepath, ignoreOldFileContent ? null
						: entry.oldFileContent, fileIsMaster);
		return true;
	};

	var saveAsFile = function(tiddler) {
		var e = entries[tiddler];
		if (e) {
			var s = getTiddlerText(tiddler);
			save(e.filepath, s);
			e.oldFileContent = s;
		}
	};

	// When a tiddler is saved and it is a "SyncFileTiddler" the corresponding
	// file is updated.
	var oldSaveTiddler = TiddlyWiki.prototype.saveTiddler;
	TiddlyWiki.prototype.saveTiddler = function(title, newTitle) {
		var result = oldSaveTiddler.apply(this, arguments);

		try {
			// "Sync" the tiddler with its file, with the tiddler being the
			// Master.
			// (Will do nothing if the tiddler is not a "SyncFileTiddler")
			SyncFileTiddler.syncTiddler(newTitle, false);
		} catch (e) {
			if (confirm("The file to sync with was modified externally.\n\n"
					+ "Press OK to overwrite anyway.\n"
					+ "Press Cancel to keep file unchanged.")) {
				saveAsFile(newTitle);
			} else if (confirm("Use the file's content as the tiddler text?")) {
				syncEntry(entries[newTitle], true);
			}
		}
		return result;
	};

	// The tiddler must be readonly when its "sync" entry is readonly
	var oldIsReadOnly = Tiddler.prototype.isReadOnly;

	Tiddler.prototype.isReadOnly = function() {
		if (oldIsReadOnly.apply(this, arguments)) {
			return true;
		}
		var e = entries[this.title];
		return e && e.readonly;
	}

	var pauseBetweenFilePolls = 2000;
	var polling = false;
	var pollFileChanges = function() {
		if (polling) {
			SyncFileTiddler.syncAll(true);

			// schedule the next time to poll for file changes
			setTimeout(pollFileChanges, pauseBetweenFilePolls);
		}
	};

	var SyncFileTiddler = {

		/**
		 * The tiddler is registered to be "synched" with the file.
		 * 
		 * If a tiddler is added more than once the last file specified is used.
		 * 
		 * @param tiddler
		 *            title of the tiddler to register
		 * @param filepath
		 *            path to the file to associate with the tiddler.
		 */
		add : function(tiddler, filepath, readonly) {
			if (!filepath.startsWith("/")) {
				// a path relative to the document
				var docPath = document.URL;
				if (!docPath.startsWith("file://"))
					return;
				var p = docPath.substring(7, docPath.lastIndexOf("/") + 1);
				filepath = p + filepath;
			}

			entries[tiddler] = {
				tiddler : tiddler,
				filepath : filepath,
				readonly : readonly,
				oldFileContent : syncTiddlerAndFile(tiddler, filepath, null,
						true),
			};
		},

		/**
		 * "Syncs" the tiddler with its file.
		 * 
		 * Will do nothing when the tiddler is not a "FileSyncTiddler" (i.e. was
		 * not registered using add)
		 */
		syncTiddler : function(tiddler, fileIsMaster) {
			var e = entries[tiddler];
			if (e) {
				syncEntry(e, fileIsMaster);
				autoSaveChanges(true);
				return true;
			} else {
				return false;
			}
		},

		syncAll : function(fileIsMaster) {
			for ( var e in entries) {
				syncEntry(entries[e], fileIsMaster);
			}
			autoSaveChanges(true);
		},

		setPolling : function(b) {
			if (b == polling)
				return;

			polling = b;
			if (polling) {
				// start polling
				pollFileChanges();
			}
		},

		isPolling : function() {
			return polling;
		},

		setPauseBetweenFilePolls : function(millis) {
			pauseBetweenFilePolls = millis;
		},
		
		getPauseBetweenFilePolls : function() {
			return pauseBetweenFilePolls;
		},
		
		addSyncFileTiddlers : function() {
			var s = store.getTiddlerText("SyncFileTiddlers");
			if (!s)
				return;

			var lines = s.split("\n");
			for ( var i = 0; i < lines.length; i++) {
				var line = lines[i];
				var a = line.split('\|');
				if (a.length >= 3) {
					var tiddler = a[1];
					var filepath = a[2];
					var readonly = a.length >= 4 && a[3]=="readonly";
					SyncFileTiddler.add(tiddler, filepath,readonly);
				}
			}
		}
	};

	namespace.SyncFileTiddler = SyncFileTiddler;

})(abego);

setTimeout(function() {
	abego.SyncFileTiddler.addSyncFileTiddlers();
	abego.SyncFileTiddler.setPolling(true);
},1);

MainMenu

Mon, 16 Apr 2012 19:50:00 GMT

About
TiddlyWiki
abego Software
News

Plugins
Installing Plugins

Download
Archive
Donations

YourSearchPlugin-src

Mon, 16 Apr 2012 17:56:00 GMT

For YourSearchPlugin source code see the archive.

YourSearchItemTemplate

Mon, 16 Apr 2012 17:56:00 GMT

<span class='yourSearchNumber' macro='foundTiddler number'></span>
<span class='yourSearchTitle' macro='foundTiddler title'/></span>&nbsp;-&nbsp;
<span macro='foundTiddler field includeURL'/></span>&nbsp;-&nbsp;
<span class='yourSearchTags' macro='foundTiddler field tags 50'/></span>
<span macro="yourSearch if previewText"><div class='yourSearchText' macro='foundTiddler field text 250'/></div></span>

ViewTemplate

Mon, 16 Apr 2012 17:55:00 GMT

<div class='toolbar' macro='toolbar -closeTiddler closeOthers +editTiddler editIncludedTiddler intelliTagsEdit permalink references jump'></div>
<div class='title' macro='view title'></div>
<div class='subtitle' macro='view includeURL'></div>
<!— <div class='subtitle'><span macro='view modifier link'></span>, <span macro='view modified date DD MMM YYYY'></span> (created <span macro='view created date DD MMM YYYY'></span>)</div>
<div class='tagging' macro='tagging'></div> >
<div class='tagged' macro='tags'></div>
<div class='viewer' macro='view text wikified'></div>
<div class='tagClear'></div>

TiddlyWikis

Mon, 16 Apr 2012 17:55:00 GMT

see TiddlyWiki