Welcome to TiddlyWiki created by Jeremy Ruston, Copyright © 2007 UnaMesa Association
A legal judgment is either TRUE, FALSE, or UNDECIDED. The judgment may be accompanied by reasons and arguments, but such reasons and arguments form no part of the judgment itself. If a judgment is accompanied by reasons and arguments, the Speaker must distribute the reasons and arguments along with the judgment.
|''URL:''|http://tiddlywiki.abego-software.de/|
|''Workspace:''|(default)|
|''Description:''|UdoBorkowski's Extensions for TiddlyWiki|
|''Author:''|UdoBorkowski|
All players must always abide by all the rules then in effect, in the form in which they are then in effect. Rules tagged with InitialSet are in effect at the beginning of the first game.
At the end of the prescribed voting period on a proposal, the Speaker shall reveal all votes legally cast on that proposal. If the Speaker's consent may be required for a proposal to be adopted, then the Speaker should indicate at that time whether or not he gives his consent. If the Speaker does not explicitly indicate that he refuses to consent to the proposal, it shall be assumed that he consents.
/***
|Name|BetterSyncPlugin|
|Created by|JeffSheets|
|Version|0.1|
|Requires|~TW2.2.4|
!Description:
Modifies the backstage synchronization system to give feedback when a tiddler has no update from the server.
!History
*07-11-07: version 0.1: First Update of the Sync system.
!Code
***/
//{{{
config.macros.sync.syncStatusList.unchangedServer = {text: "Unchanged on Server", color: '#808080'};
config.macros.sync.createSyncTask = function(syncItem)
{
var st = {};
st.serverType = syncItem.serverType;
st.serverHost = syncItem.serverHost;
st.serverWorkspace = syncItem.serverWorkspace;
st.syncItems = [syncItem];
st.syncMachine = new SyncMachine(st.serverType,{
start: function() {
return this.openHost(st.serverHost,"openWorkspace");
},
openWorkspace: function() {
return this.openWorkspace(st.serverWorkspace,"getTiddlerList");
},
getTiddlerList: function() {
return this.getTiddlerList("gotTiddlerList");
},
gotTiddlerList: function(tiddlers) {
for(var t=0; t<st.syncItems.length; t++) {
var si = st.syncItems[t];
var f = tiddlers.findByField("title",si.title);
if(f !== null) {
if(tiddlers[f].fields['server.page.revision'] > si.tiddler.fields['server.page.revision']) {
si.syncStatus = config.macros.sync.syncStatusList[si.isTouched ? 'changedBoth' : 'changedServer'];
} else {
si.syncStatus = config.macros.sync.syncStatusList.unchangedServer;
}
} else {
si.syncStatus = config.macros.sync.syncStatusList.notFound;
}
config.macros.sync.updateSyncStatus(si);
}
},
getTiddler: function(title) {
return this.getTiddler(title,"onGetTiddler");
},
onGetTiddler: function(tiddler) {
var syncItem = st.syncItems.findByField("title",tiddler.title);
if(syncItem !== null) {
syncItem = st.syncItems[syncItem];
store.saveTiddler(tiddler.title, tiddler.title, tiddler.text, tiddler.modifier, tiddler.modified, tiddler.tags, tiddler.fields, true, tiddler.created);
syncItem.syncStatus = config.macros.sync.syncStatusList.gotFromServer;
config.macros.sync.updateSyncStatus(syncItem);
}
},
putTiddler: function(tiddler) {
return this.putTiddler(tiddler,"onPutTiddler");
},
onPutTiddler: function(tiddler) {
var syncItem = st.syncItems.findByField("title",tiddler.title);
if(syncItem !== null) {
syncItem = st.syncItems[syncItem];
store.resetTiddler(tiddler.title);
syncItem.syncStatus = config.macros.sync.syncStatusList.putToServer;
config.macros.sync.updateSyncStatus(syncItem);
}
}
});
st.syncMachine.go();
return st;
};
//}}}
/***
|Name|BetterTimelineMacro|
|Created by|SaqImtiaz|
|Location|http://tw.lewcid.org/#BetterTimelineMacro|
|Version|0.5 beta|
|Requires|~TW2.x|
!!!Description:
A replacement for the core timeline macro that offers more features:
*list tiddlers with only specfic tag
*exclude tiddlers with a particular tag
*limit entries to any number of days, for example one week
*specify a start date for the timeline, only tiddlers after that date will be listed.
!!!Installation:
Copy the contents of this tiddler to your TW, tag with systemConfig, save and reload your TW.
Edit the ViewTemplate to add the fullscreen command to the toolbar.
!!!Syntax:
{{{<<timeline better:true>>}}}
''the param better:true enables the advanced features, without it you will get the old timeline behaviour.''
additonal params:
(use only the ones you want)
{{{<<timeline better:true onlyTag:Tag1 excludeTag:Tag2 sortBy:modified/created firstDay:YYYYMMDD maxDays:7 maxEntries:30>>}}}
''explanation of syntax:''
onlyTag: only tiddlers with this tag will be listed. Default is to list all tiddlers.
excludeTag: tiddlers with this tag will not be listed.
sortBy: sort tiddlers by date modified or date created. Possible values are modified or created.
firstDay: useful for starting timeline from a specific date. Example: 20060701 for 1st of July, 2006
maxDays: limits timeline to include only tiddlers from the specified number of days. If you use a value of 7 for example, only tiddlers from the last 7 days will be listed.
maxEntries: limit the total number of entries in the timeline.
!!!History:
*28-07-06: ver 0.5 beta, first release
!!!Code
***/
//{{{
// Return the tiddlers as a sorted array
TiddlyWiki.prototype.getTiddlers = function(field,excludeTag,includeTag)
{
var results = [];
this.forEachTiddler(function(title,tiddler)
{
if(excludeTag == undefined || tiddler.tags.find(excludeTag) == null)
if(includeTag == undefined || tiddler.tags.find(includeTag)!=null)
results.push(tiddler);
});
if(field)
results.sort(function (a,b) {if(a[field] == b[field]) return(0); else return (a[field] < b[field]) ? -1 : +1; });
return results;
}
//this function by Udo
function getParam(params, name, defaultValue)
{
if (!params)
return defaultValue;
var p = params[0][name];
return p ? p[0] : defaultValue;
}
window.old_timeline_handler= config.macros.timeline.handler;
config.macros.timeline.handler = function(place,macroName,params,wikifier,paramString,tiddler)
{
var args = paramString.parseParams("list",null,true);
var betterMode = getParam(args, "better", "false");
if (betterMode == 'true')
{
var sortBy = getParam(args,"sortBy","modified");
var excludeTag = getParam(args,"excludeTag",undefined);
var includeTag = getParam(args,"onlyTag",undefined);
var tiddlers = store.getTiddlers(sortBy,excludeTag,includeTag);
var firstDayParam = getParam(args,"firstDay",undefined);
var firstDay = (firstDayParam!=undefined)? firstDayParam: "00010101";
var lastDay = "";
var field= sortBy;
var maxDaysParam = getParam(args,"maxDays",undefined);
var maxDays = (maxDaysParam!=undefined)? maxDaysParam*24*60*60*1000: (new Date()).getTime() ;
var maxEntries = getParam(args,"maxEntries",undefined);
var last = (maxEntries!=undefined) ? tiddlers.length-Math.min(tiddlers.length,parseInt(maxEntries)) : 0;
for(var t=tiddlers.length-1; t>=last; t--)
{
var tiddler = tiddlers[t];
var theDay = tiddler[field].convertToLocalYYYYMMDDHHMM().substr(0,8);
if ((theDay>=firstDay)&& (tiddler[field].getTime()> (new Date()).getTime() - maxDays))
{
if(theDay != lastDay)
{
var theDateList = document.createElement("ul");
place.appendChild(theDateList);
createTiddlyElement(theDateList,"li",null,"listTitle",tiddler[field].formatString(this.dateFormat));
lastDay = theDay;
}
var theDateListItem = createTiddlyElement(theDateList,"li",null,"listLink",null);
theDateListItem.appendChild(createTiddlyLink(place,tiddler.title,true));
}
}
}
else
{
window.old_timeline_handler.apply(this,arguments);
}
}
//}}}
|''URL:''|http://tiddlywiki.bidix.info/|
|''Workspace:''|(default)|
|''Description:''|Repository for BidiX's TiddlyWiki Extensions|
|''Author:''|BidiX|
|''URL:''|http://bob.mcelrath.org/plugins.html|
|''Workspace:''|(default)|
|''Description:''|Bob McElrath's Plugins|
|''Author:''|BobMcElrath|
/***
| Name|CloseOnCancelPlugin|
| Description|Closes the tiddler if you click new tiddler then cancel. Default behaviour is to leave it open|
| Version|3.0 ($Rev: 1845 $)|
| Date|$Date: 2007-03-16 15:19:22 +1000 (Fri, 16 Mar 2007) $|
| Source|http://mptw.tiddlyspot.com/#CloseOnCancelPlugin|
| Author|Simon Baird <simon.baird@gmail.com>|
| License|http://mptw.tiddlyspot.com/#TheBSDLicense|
***/
//{{{
merge(config.commands.cancelTiddler,{
handler_orig_closeUnsaved: config.commands.cancelTiddler.handler,
handler: function(event,src,title) {
this.handler_orig_closeUnsaved(event,src,title);
if (!store.tiddlerExists(title) && !store.isShadowTiddler(title))
story.closeTiddler(title,true);
return false;
}
});
//}}}
/***
|Name|CopyTiddlerPlugin|
|Source|http://www.TiddlyTools.com/#CopyTiddlerPlugin|
|Version|3.0.0|
|Author|Eric Shulman - ELS Design Studios|
|License|http://www.TiddlyTools.com/#LegalStatements <<br>>and [[Creative Commons Attribution-ShareAlike 2.5 License|http://creativecommons.org/licenses/by-sa/2.5/]]|
|~CoreVersion|2.1|
|Type|plugin|
|Requires||
|Overrides||
|Description|Quickly create a copy of any existing tiddler|
!!!!!Usage
<<<
View a tiddler and select the "copy" toolbar item. A new tiddler editor is opened with a title of "Copy of TiddlerName" containing copies of the text/tags from the original tiddler. Note: If select the "copy" toolbar item while //editing// a tiddler, the current values of the text/tags that are displayed in the existing tiddler editor are used (including any unsaved changes you may have made to those values).
<<<
!!!!!Installation
<<<
import (or copy/paste) the following tiddlers into your document:
''CopyTiddlerPlugin'' (tagged with <<tag systemConfig>>)
* When using the default (shadow) EditTemplate, the plugin automatically updates the template to include the ''copyTiddler'' toolbar command.
* If you have created a custom EditTemplate tiddler, you will need to manually add the ''copyTiddler'' toolbar command to your existing template toolbar definition.
* If you add ''copyTiddler'' to the ViewTemplate toolbar definition, the ''copy'' toolbar command will also appear when viewing a tiddler.
{{{
<!-- add 'copyTiddler' command to existing toolbar definition -->
<div class='toolbar' macro='toolbar ... copyTiddler ... '>
}}}
<<<
!!!!!Revisions
<<<
''2007.06.28 [3.0.0]'' complete re-write to handle custom fields and alternative view/edit templates
''2007.05.17 [2.1.2]'' use store.getTiddlerText() to retrieve tiddler content, so that SHADOW tiddlers can be copied correctly when in VIEW mode
''2007.04.01 [2.1.1]'' in copyTiddler.handler(), fix check for editor fields by ensuring that found field actually has edit=="text" attribute
''2007.02.05 [2.1.0]'' in copyTiddler.handler(), if editor fields (textfield and/or tagsfield) can't be found (i.e., tiddler is in VIEW mode, not EDIT mode), then get text/tags values from stored tiddler instead of active editor fields. Allows use of COPY toolbar directly from VIEW mode (based on a request from LaurentCharles)
''2006.12.12 [2.0.0]'' completely rewritten so plugin just creates a new tiddler EDITOR with a copy of the current tiddler EDITOR contents, instead of creating the new tiddler in the STORE by copying the current tiddler values from the STORE.
''2005.xx.xx [1.0.0]'' original version by Tim Morgan
<<<
!!!!!Credits
>This feature was originally developed by Tim Morgan. Current version developed by EricShulman from [[ELS Design Studios|http://www.elsdesign.com]]
!!!!!Code
***/
//{{{
version.extensions.copyTiddler= {major: 3, minor: 0, revision: 0, date: new Date(2007,6,28)};
// automatically tweak shadow EditTemplate to add "copyTiddler" toolbar command (following "cancelTiddler")
config.shadowTiddlers.EditTemplate=config.shadowTiddlers.EditTemplate.replace(/cancelTiddler/,"cancelTiddler copyTiddler");
config.commands.copyTiddler = {
text: 'copy',
hideReadOnly: true,
tooltip: 'Make a copy of this tiddler',
prefix: "Copy of ",
handler: function(event,src,title) {
var tiddlerElem=document.getElementById(story.idPrefix+title); // current tiddler element
var template=tiddlerElem.getAttribute("template") // current tiddler template
var newTitle = this.prefix+title; // add "copy of" to create new tiddler title
if (!story.isDirty(title)) { // if existing tiddler is being VIEWED (not EDITED)
// duplicate existing stored tiddler (and clear "changecount")
var tid=store.getTiddler(title);
store.saveTiddler(newTitle,newTitle,tid.text,config.options.txtUserName,new Date(),tid.tags, tid.fields, true);
// display new tiddler using same view template as current tiddler
story.displayTiddler(story.findContainingTiddler(src),newTitle,template);
} else {
// display new tiddler editor using same editor template as current tiddler
story.displayTiddler(story.findContainingTiddler(src),newTitle,template);
// get fields from current tiddler editor
var fields=config.commands.copyTiddler.gatherFields(tiddlerElem);
// set fields in new editor
var newTiddlerElem = document.getElementById(story.idPrefix+newTitle);
for (var f=0; f<fields.length; f++) {
if (fields[f].name=="title") fields[f].value=newTitle; // rename title in new tiddler
var fieldElem=config.commands.copyTiddler.findField(newTiddlerElem,fields[f].name);
if (fieldElem) {
if (fieldElem.getAttribute("type")=="checkbox")
fieldElem.checked=fields[f].value;
else
fieldElem.value=fields[f].value;
}
}
}
story.focusTiddler(newTitle,"title");
return false;
},
findField: function(tiddlerElem,field) {
var inputs=tiddlerElem.getElementsByTagName("input");
for (var i=0; i<inputs.length; i++) {
if (inputs[i].getAttribute("type")=="checkbox" && inputs[i].field == field) return inputs[i];
if (inputs[i].getAttribute("type")=="text" && inputs[i].getAttribute("edit") == field) return inputs[i];
}
var tas=tiddlerElem.getElementsByTagName("textarea");
for (var i=0; i<tas.length; i++) if (tas[i].getAttribute("edit") == field) return tas[i];
var sels=tiddlerElem.getElementsByTagName("select");
for (var i=0; i<sels.length; i++) if (sels[i].getAttribute("edit") == field) return sels[i];
return null;
},
gatherFields: function(tiddlerElem) { // get field names and values from current tiddler editor
var fields=[];
// get checkboxes and edit fields
var inputs=tiddlerElem.getElementsByTagName("input");
for (var i=0; i<inputs.length; i++) {
if (inputs[i].getAttribute("type")=="checkbox")
if (inputs[i].field) fields.push({name:inputs[i].field,value:inputs[i].checked});
if (inputs[i].getAttribute("type")=="text")
if (inputs[i].getAttribute("edit")) fields.push({name:inputs[i].getAttribute("edit"),value:inputs[i].value});
}
// get textareas (multi-line edit fields)
var tas=tiddlerElem.getElementsByTagName("textarea");
for (var i=0; i<tas.length; i++)
if (tas[i].getAttribute("edit")) fields.push({name:tas[i].getAttribute("edit"),value:tas[i].value});
// get selection lists (droplist or listbox)
var sels=tiddlerElem.getElementsByTagName("select");
for (var i=0; i<sels.length; i++)
if (sels[i].getAttribute("edit")) fields.push({name:sels[i].getAttribute("edit"),value:sels[i].value});
return fields;
}
};
//}}}
<<list byTag "Proposal">>
[[Introduction]]
[[Recent Changes]]
The Second Voter to join up.
/***
|Name|EditFieldPlugin|
|Source|http://www.TiddlyTools.com/#EditFieldPlugin|
|Version|1.0.0|
|Author|Eric Shulman - ELS Design Studios|
|License|http://www.TiddlyTools.com/#LegalStatements <<br>>and [[Creative Commons Attribution-ShareAlike 2.5 License|http://creativecommons.org/licenses/by-sa/2.5/]]|
|~CoreVersion|2.1|
|Type|plugin|
|Requires||
|Overrides||
|Description|extend core edit macro for use in ViewTemplates or direct embedding in tiddler content|
This HIJACK extends the core {{{<<edit fieldname>>}}} macro for use in a ViewTemplate or directly embedded in tiddler content. Enter single- or multi- line text from 'view mode' tiddler displays and save/discard your input using ENTER, ESC, or automatic 'blur' handling.
!!!!!Usage
<<<
Normally, when you edit a tiddler, any changes you make are only saved (or discarded) when you press the "done" (or "cancel") command in the tiddler editor's toolbar. However, when in a 'view mode' context, these command items are not available, and so cannot be used to trigger the 'save/discard' handling once you have decided that your input activities are complete. Instead, you will be automatically prompted to save/discard your changes (if any) as soon as you move away from a text edit field or multi-line text area. Alternatively, pressing ENTER while in an edit field will save your input, while pressing ESCAPE will abandon your input (after prompting for confirmation).
<<<
!!!!!Examples
<<<
{{{<<edit foobar>>}}}
<<edit foobar>>
{{{<<edit mumble 5>>}}}
<<edit mumble 5>>
<<<
!!!!!Installation
<<<
import (or copy/paste) the following tiddlers into your document: [[EditFieldPlugin]]
<<<
!!!!!Revision History
<<<
''2007.08.22 [1.0.0]'' initial release
<<<
!!!!!Credits
<<<
This feature was developed by Eric L Shulman / ELS Design Studios
<<<
!!!!!Code
***/
//{{{
version.extensions.editFieldPlugin= {major: 1, minor: 0, revision: 0, date: new Date(2007,8,22)};
config.macros.edit.editFieldPlugin_savedHandler=config.macros.edit.handler;
config.macros.edit.handler = function(place,macroName,params,wikifier,paramString,tiddler) {
// let core create edit field
config.macros.edit.editFieldPlugin_savedHandler.apply(this,arguments);
// get edit field or textarea
var ins=place.getElementsByTagName(params[0]=="text"||params[1]?'textarea':'input');
var e=ins[ins.length-1];
// if viewing tiddler, add autosave handlers
var here=story.findContainingTiddler(place);
if (here && here.getAttribute("template").indexOf("ViewTemplate")!=-1) {
story.setDirty(tiddler.title,false); // clear tiddler ("dirty") flag set by core when field was created
var field=e.getAttribute("edit");
var val=store.getValue(tiddler.title,field); if (!val) val="";
e.setAttribute("currval",val); // remember starting value
e.setAttribute("tiddler",tiddler.title); // remember target tiddler
e.onkeydown=function(ev) { // ENTER key=save (for single-line edit fields only)
var event=ev?ev:window.event;
this.setAttribute("keyCode",event.keyCode); // save last keyCode for blur() handler
if (event.keyCode==13 && this.nodeName.toUpperCase()!="TEXTAREA")
this.saveField(); // save input to tiddler field
}
e.onblur=function(ev) { // accept or reject input when focus moves away from field
var event=ev?ev:window.event;
var tid=this.getAttribute("tiddler"); if (!tid || !tid.length) return;
var field=this.getAttribute("edit");
if (this.value!=this.getAttribute("currval")) { // if value has changed
if (this.getAttribute("keyCode")=="27") { // if user pressed ESC
var msg="Abandon changes to %0@%1?".format([field,tid]);
if (confirm(msg)) this.value=this.getAttribute("currval"); // reset to starting value
this.id=new Date().getTime(); // set unique ID
setTimeout("document.getElementById('"+this.id+"').focus()",1); // restore focus (after blur completes)
} else { // other focus change events
var msg="Save changes to %0@%1?".format([field,tid]);
if (confirm(msg)) this.saveField(); // save input to tiddler field, then continue blur
else this.value=this.getAttribute("currval"); // reset to starting value, then continue blur
}
}
};
e.saveField=function() { // save input value to tiddler field (create, touch or rename tiddler as needed)
var tid=this.getAttribute("tiddler"); if (!tid || !tid.length) return;
var field=this.getAttribute("edit");
var title=(field=="title")?this.value:tid;
if (!title.length) { // prevent blank tiddler title from being used
this.value=this.getAttribute("currval"); // reset to starting value
this.id=new Date().getTime(); // set unique ID
setTimeout("displayMessage('Please enter a non-blank value')",1); // notify user
setTimeout("document.getElementById('"+this.id+"').focus()",2); // set focus to continue editing
return;
}
var t=store.getTiddler(tid);
store.suspendNotifications();
var anim=config.options.chkAnimate; config.options.chkAnimate=false; // suspend animation
store.saveTiddler(t?tid:title,title,t?t.body:"",config.options.txtUserName,new Date(),t?t.tags:[],t?t.fields:null);
store.setValue(title,field,this.value); // save value in tiddler field
this.setAttribute("currval",this.value); // remember new starting value
if (tid!=title) // if title changed, display renamed tiddler in place of current one
{ story.displayTiddler(story.findContainingTiddler(this),title); story.closeTiddler(tid); }
if (field=="text") // if tiddler content changed, refresh tiddler display
{ story.refreshTiddler(title,null,true); }
config.options.chkAnimate=anim; // resume animation
store.resumeNotifications();
};
}
}
//}}}
<!--{{{-->
<div class='toolbar' macro='toolbar +saveTiddler saveCloseTiddler -cancelTiddler cancelCloseTiddler copyTiddler deleteTiddler'></div>
<div class='title' macro='view title'></div>
<div class='editor' macro='edit title'></div>
<div macro='annotations'></div>
<div class='editor' macro='edit text'></div>
<div class='editor' macro='edit tags'></div><div class='editorFooter'><span macro='message views.editor.tagPrompt'></span><span macro='tagChooser'></span></div>
<!--}}}-->
|''URL:''|http://gimcrackd.com/etc/src/|
|''Workspace:''|(default)|
|''Description:''|Gimcrack'd: Code and Other Oddments|
|''Author:''|ChrisKlimas|
/***
|Name|HTMLFormattingPlugin|
|Source|http://www.TiddlyTools.com/#HTMLFormattingPlugin|
|Version|2.1.5|
|Author|Eric Shulman - ELS Design Studios|
|License|http://www.TiddlyTools.com/#LegalStatements <<br>>and [[Creative Commons Attribution-ShareAlike 2.5 License|http://creativecommons.org/licenses/by-sa/2.5/]]|
|~CoreVersion|2.1|
|Type|plugin|
|Requires||
|Overrides|'HTML' formatter|
|Description|embed wiki syntax formatting inside of HTML content|
The shorthand Wiki-style formatting syntax of ~TiddlyWiki is very convenient and enables most content to be reasonably well presented. However, there are times when tried-and-true HTML formatting syntax allows more more precise control of the content display.
When HTML formatting syntax is embedded within a tiddler (in between {{{<}}}{{{html>}}} and {{{<}}}{{{/html>}}} markers) TiddlyWiki passes this content to the browser for processing as 'native' HTML. However, TiddlyWiki does not also process the HTML source content for any embedded wiki-formatting syntax it may contain. This means that while you can use HTML formatted content, you cannot mix wiki-formatted content within the HTML formatting.
!!!!!Usage
<<<
The ~HTMLFormatting plugin allows you to freely ''mix wiki-style formatting syntax within HTML formatted content'' by extending the action of the standard TiddlyWiki formatting handler.
When a tiddler is about to be displayed, ~TiddlyWiki looks for tiddler content contained within ''<{{{html}}}>'' and ''<{{{/html}}}>'' HTML tags. This content (if any) is passed directly to the browser's internal "rendering engine" to process as ~HTML-formatted content. Once the HTML formatting has been processed, all the pieces of text occuring in between the HTML formatting are then processed by the ~TiddlyWiki rendering engine, one piece at a time, so that normal wiki-style formatting can be applied to the individual text pieces.
<<<
!!!!!Line breaks
<<<
One major difference between Wiki formatting and HTML formatting is how "line breaks" are processed. Wiki formatting treats all line breaks as literal content to be displayed //as-is//. However, because HTML normally ignores line breaks and actually processes them as simple "word separators" instead, many people who write HTML include extra line breaks in their documents, just to make the "source code" easier to read.
Even though you can use HTML tags within your tiddler content, the default treatment for line breaks still follows the Wiki-style rule (i.e., all new lines are displayed as-is). When adding HTML content to a tiddler (especially if you cut-and-paste it from another web page), you should take care to avoid adding extra line breaks to the text.
If removing all the extra line breaks from your HTML content would be a big hassle, you can quickly //override the default Wiki-style line break rule// so that the line breaks use the standard HTML rules instead. Placing a ''<{{{hide linebreaks}}}>'' tag within the tiddler's HTML content changes all line breaks to spaces before rendering the content, so that the literal line breaks will be processed as simple word-breaks instead.
Note: this does //not// alter the actual tiddler content that is stored in the document, just the manner in which it is displayed. Any line breaks contained in the tiddler will still be there when you edit its content. Also, to include a literal line break when the ''<{{{hide linebreaks}}}>'' tag is present, you will need to use a ''<{{{br}}}>'' or ''<{{{p}}}>'' HTML tag instead of simply typing a line break.
<<<
!!!!!How it works
<<<
The TW core support for HTML does not let you put ANY wiki-style syntax (including TW macros) *inside* the {{{<html>...</html>}}} block. Everything between {{{<html>}}} and {{{</html>}}} is handed to the browser for processing and that is it. Fortunately, this plugin ADDS the ability to let you put wiki-syntax (including macros) inside the html. It does this by first giving the tiddler source content to the browser to process the HTML, and then handling any wiki-based syntax that remains afterward.
However, not all wiki syntax can be safely passed through the browser's parser. Specifically, any TW macros inside the HTML will get 'eaten' by the browser since the macro brackets, {{{<<...>>}}} use the "<" and ">" that normally delimit the HTML/XML syntax recognized by the browser's parser.
Similarly, you can't use InlineJavascript within the HTML because the {{{<script>...</script>}}} syntax will also be consumed by the browser and there will be nothing left to process afterward. Note: unfortunately, even though the browser removes the {{{<script>...</script>}}} sequence, it doesn't actually execute the embedded javascript code that it removes, so any scripts contained inside of <html> blocks in TW are currently being ignored. :-(
As a work-around to allow TW *macros* (but not inline scripts) to exist inside of <html> formatted blocks of content, the plugin first converts the {{{<<}}} and {{{>>}}} into "%%(" and ")%%", making them "indigestible" so they can pass unchanged through the belly of the beast (the browser's HTML parser).
After the browser has done its job, the wiki syntax sequences (including the "undigested" macros) are contained in #text nodes in the browser-generated DOM elements. The plugin then recursively locates and processes each #text node, converts the %%( and )%% back into {{{<<}}} and {{{>>}}}, passes the result to wikify() for further rendering of the wiki-formatted syntax into a containing SPAN that replaces the previous #text node. At the end of this process, none of the encoded %%( and )%% sequences remain in the rendered tiddler output.
<<<
!!!!!Installation
<<<
import (or copy/paste) the following tiddlers into your document:
''HTMLFormattingPlugin'' (tagged with <<tag systemConfig>>)
^^documentation and javascript for HTMLFormatting handling^^
<<<
!!!!!Revision History
<<<
''2007.06.14 [2.1.5]'' in formatter, removed call to e.normalize(). Creates an INFINITE RECURSION error in Safari!!!!
''2006.09.10 [2.1.4]'' update formatter for 2.1 compatibility (use this.lookaheadRegExp instead of temp variable)
''2006.05.28 [2.1.3]'' in wikifyTextNodes(), decode the *value* of TEXTAREA nodes, but don't wikify() its children. (thanks to "ayj" for bug report)
''2006.02.19 [2.1.2]'' in wikifyTextNodes(), put SPAN element into tiddler DOM (replacing text node), BEFORE wikifying the text content. This ensures that the 'place' passed to any macros is correctly defined when the macro is evaluated, so that calls to story.findContainingTiddler(place) will work as expected. (Thanks for bug report from GeoffSlocock)
''2006.02.05 [2.1.1]'' wrapped wikifier hijack in init function to eliminate globals and avoid FireFox 1.5.0.1 crash bug when referencing globals
''2005.12.01 [2.1.0]'' don't wikify #TEXT nodes inside SELECT and TEXTAREA elements
''2005.11.06 [2.0.1]'' code cleanup
''2005.10.31 [2.0.0]'' replaced hijack wikify() with hijack config.formatters["html"] and simplified recursive WikifyTextNodes() code
''2005.10.09 [1.0.2]'' combined documentation and code into a single tiddler
''2005.08.05 [1.0.1]'' moved HTML and CSS definitions into plugin code instead of using separate tiddlers
''2005.07.26 [1.0.1]'' Re-released as a plugin. Added <{{{html}}}>...</{{{nohtml}}}> and <{{{hide newlines}}}> handling
''2005.07.20 [1.0.0]'' Initial Release (as code adaptation)
<<<
!!!!!Credits
<<<
This feature was developed by EricShulman from [[ELS Design Studios|http:/www.elsdesign.com]]
<<<
!!!!!Code
***/
//{{{
version.extensions.HTMLFormatting = {major: 2, minor: 1, revision: 5, date: new Date(2007,6,14)};
// find the formatter for HTML and replace the handler
initHTMLFormatter();
function initHTMLFormatter()
{
for (var i=0; i<config.formatters.length && config.formatters[i].name!="html"; i++);
if (i<config.formatters.length) config.formatters[i].handler=function(w) {
if (!this.lookaheadRegExp) // fixup for TW2.0.x
this.lookaheadRegExp = new RegExp(this.lookahead,"mg");
this.lookaheadRegExp.lastIndex = w.matchStart;
var lookaheadMatch = this.lookaheadRegExp.exec(w.source)
if(lookaheadMatch && lookaheadMatch.index == w.matchStart) {
var html=lookaheadMatch[1];
// optionally suppress wiki-style literal handling of newlines
// strip any carriage returns added by Internet Explorer's textarea edit field
// encode newlines as \n so Internet Explorer's HTML parser won't eat them
// encode macro brackets (<< and >>) so HTML parser won't eat them
if (html.indexOf('<hide linebreaks>')!=-1) html=html.replace(regexpNewLine,' ');
html=html.replace(regexpCarriageReturn,'');
html=html.replace(regexpNewLine,'\\n');
html=html.replace(/<</g,'%%(').replace(/>>/g,')%%');
// create span to hold HTML
// parse HTML and normalize the results
// walk node tree and call wikify() on each text node
var e = createTiddlyElement(w.output,"span");
e.innerHTML=html;
// REMOVED: e.normalize(); // THIS CAUSED INFINITE RECURSION IN SAFARI
wikifyTextNodes(e);
// advance to next parse position
w.nextMatch = this.lookaheadRegExp.lastIndex;
}
}
}
// wikify text nodes remaining after HTML content is processed (pre-order recursion)
function wikifyTextNodes(theNode)
{
// textarea node doesn't get wikified, just decoded...
if (theNode.nodeName.toLowerCase()=='textarea')
theNode.value=theNode.value.replace(/\%%\(/g,'<<').replace(/\)\%%/g,'>>').replace(regexpBackSlashEn,'\n');
else for (var i=0;i<theNode.childNodes.length;i++) {
var theChild=theNode.childNodes.item(i);
if (theChild.nodeName.toLowerCase()=='option') continue;
if (theChild.nodeName.toLowerCase()=='select') continue;
wikifyTextNodes(theChild);
if (theChild.nodeName=='#text') {
var txt=theChild.nodeValue;
// decode macro brackets and newlines
txt=txt.replace(/\%%\(/g,'<<').replace(/\)\%%/g,'>>').replace(regexpBackSlashEn,'\n');
// replace text node with wikified() span
var newNode=createTiddlyElement(null,"span");
theNode.replaceChild(newNode,theChild);
wikify(txt,newNode);
}
}
}
//}}}
/***
|Name|HideNoTagsBoxPlugin|
|Created by|JeffSheets|
|Version|0.1|
|Requires|~TW2.2.4+|
!Description:
Hides the tags box when there are no tags associated with the current tiddler.
The following CSS styles are automatically added as a custom stylesheet, along with the change to ''Story.prototype.refreshTiddler'', to make this work.
{{{
.tagged {display: none;}
.isTagged .tagged {display: block;}
}}}
!History
*21-07-07: version 0.1: first version.
!Code
***/
//{{{
Story.prototype.refreshTiddler = function(title,template,force,customFields,defaultText)
{
var tiddlerElem = document.getElementById(this.idPrefix + title);
if(tiddlerElem) {
if(tiddlerElem.getAttribute("dirty") == "true" && !force)
return tiddlerElem;
template = this.chooseTemplateForTiddler(title,template);
var currTemplate = tiddlerElem.getAttribute("template");
if((template != currTemplate) || force) {
var tiddler = store.getTiddler(title);
if(!tiddler) {
tiddler = new Tiddler();
if(store.isShadowTiddler(title)) {
tiddler.set(title,store.getTiddlerText(title),config.views.wikified.shadowModifier,version.date,[],version.date);
} else {
var text = template=="EditTemplate" ?
config.views.editor.defaultText.format([title]) :
config.views.wikified.defaultText.format([title]);
text = defaultText ? defaultText : text;
var fields = customFields ? customFields.decodeHashMap() : null;
tiddler.set(title,text,config.views.wikified.defaultModifier,version.date,[],version.date,fields);
}
}
tiddlerElem.setAttribute("tags",tiddler.tags.join(" "));
tiddlerElem.setAttribute("tiddler",title);
tiddlerElem.setAttribute("template",template);
var me = this;
tiddlerElem.onmouseover = this.onTiddlerMouseOver;
tiddlerElem.onmouseout = this.onTiddlerMouseOut;
tiddlerElem.ondblclick = this.onTiddlerDblClick;
tiddlerElem[window.event?"onkeydown":"onkeypress"] = this.onTiddlerKeyPress;
var html = this.getTemplateForTiddler(title,template,tiddler);
tiddlerElem.innerHTML = html;
applyHtmlMacros(tiddlerElem,tiddler);
if(store.getTaggedTiddlers(title).length > 0)
addClass(tiddlerElem,"isTag");
else
removeClass(tiddlerElem,"isTag");
if (tiddler.tags.length > 0) {
addClass(tiddlerElem,"isTagged");
} else {
removeClass(tiddlerElem,"isTagged");
}
if(!store.tiddlerExists(title)) {
if(store.isShadowTiddler(title))
addClass(tiddlerElem,"shadow");
else
addClass(tiddlerElem,"missing");
} else {
removeClass(tiddlerElem,"shadow");
removeClass(tiddlerElem,"missing");
}
if(customFields)
this.addCustomFields(tiddlerElem,customFields);
forceReflow();
}
}
return tiddlerElem;
};
setStylesheet("\n.tagged {display: none;}\n.isTagged .tagged {display: block;}\n","HideNoTagsStyleSheet",document);
//}}}
Simply request to join the [[Google Group|http://groups.google.com/group/tiddlynomic]]. Once you are accepted as a player, you should change your nickname by clicking on ''Edit my Membership'' on the right hand side of the Google Group page. After you pick a Nickname, you will be added to the Public Knowledge section of this Wiki.
Simply //Reply// to [[this post|http://groups.google.com/group/tiddlynomic/browse_thread/thread/1804a9ae3a4cd72a/2e8f090d3a47eb32#2e8f090d3a47eb32]] with your proposal. Do not give your proposal a number; that's the Speaker's job!
As soon as the Speaker is able to, he will update the TiddlyNomic Wiki, and the Voting Period on that proposal begins. He'll also post a new thread to collect votes and allow discussion on the proposal.
If you want to suggest a proposal, but aren't sure how it should be worded, or want discussion on it before actually proposing it, post a separate thread asking for discussion on your possible rule change.
Voters may vote either for or against any proposal within its prescribed voting period. In order to be legally cast, the vote must be received by the Speaker before the end of the prescribed voting period. The Speaker may not reveal any votes until the end of the prescribed voting period. Any Voter who does not legally vote within the prescribed voting period shall be deemed to have abstained.
[[Submit a Proposal|How To Submit a Proposal]]
[[Vote on Current Proposals|How to Vote on a Proposal]]
[[Invoke Judgment|How to Submit a Statement for Judgment]]
And of course, as more Rules are voted in or out, this list will change over time.
To Submit a Statement for Judgment, one must simply post their statement at the Google Group, with a heading of ''Statement for Judgment''. The Speaker will shortly afterward add the Statement to the list of Judgments here on the Wiki, and will follow the rules to ensure a Judgment is reached.
Each current proposal listed here will have a link to the Google Group post where voting should take place. Just click that link and post a Vote for or against the proposal. One vote per Player.
<<list byTag "Immutable">>
<<rulelist byTag "Immutable">>
<!--{{{-->
<div class='toolbar' macro='toolbar closeTiddler closeOthers +editTiddler > fields syncing permalink references jump'></div>
<div class='title'><span class='rulesmall' macro='view rulenum'></span><span class='rulesmall'>.</span> <span macro='view title'></span> <span class='rulesmall'>Rev. </span><span class='rulesmall' macro='view revnum'></span><span class='rulesmall'> [Immutable]</span></div>
<div class='tagged' macro='tags'></div>
<div class='subtitle'><span macro='view modifier link'></span>, <span macro='view modified date'></span> (<span macro='message views.wikified.createdPrompt'></span> <span macro='view created date'></span>)</div>
<div class='tagging' macro='tagging'></div>
<div class='viewer' macro='view text wikified'></div>
<div class='tagClear'></div>
<!--}}}-->
<<rulelist byTag "Rule">>
TiddlyNomic is a game for rules-lawyers and gaming munchkinism. Not only are the players allowed to change the rules, doing so in a creatively insidious manner is encouraged. Indeed, changing the rules is the only way to win the game.
Times of various Tiddlers are listed in Central Daylight Time (Currently ~UTC-7:00 I believe). The Clock in the upper right hand side is supposed to show CDT time, but if you think it isn't, please let JeffSheets know.
If players disagree about the legality of a move or the interpretation or application of a rule, then a player may invoke judgment by submitting a statement for judgment to the Speaker. Disagreement, for the purposes of this rule, may be created by the insistence of any player. When judgment is invoked, the Speaker must, as soon as possible, select a Judge as described in the Rules. The Speaker must then distribute the statement to be judged, along with the identity of the Judge, to all players.
|''URL:''|http://jackparke.googlepages.com/jtw.html|
|''Workspace:''|(default)|
|''Description:''|Plugins, Macros and Hacks|
|''Author:''|JackParker|
Jeff Sheets is the Current Speaker of ~TiddlyNomic. He can be reached by sending an email to jeff.sheets (at) insightbb.com or to sheets.jeff (at) gmail.com.
<<list byTag "Judgment">>
All judgments must be in accordance with the rules; however, if the rules are silent, inconsistent, or unclear on the statement to be judged, then the Judge shall consider game custom and the spirit of the game before applying other standards.
KudoCash is the Official currency of TiddlyNomic. All players, as of the time this rule is enacted, and all new players joining later, receive 100 KudoCash. KudoCash owned by a player is Public Knowledge, and will be listed on their Tiddler in the Wiki.
|''URL:''|http://tw.lewcid.org/|
|''Workspace:''|(default)|
|''Description:''|a repository of my extensions for TW|
|''Author:''|SaqImtiaz|
[[Introduction]]
[[How To Join]]
[[How to Play]]
[[Recent Changes]]
[[The Rules]]
[[Current Proposals]]
[[Public Knowledge]]
[[Judgments]]
^^[[TiddlyWiki|http://www.tiddlywiki.com]] <<version>>
© 2007 [[UnaMesa|http://www.unamesa.org/]]^^
After the Speaker has distributed the statement to be judged and the identity of the Judge, the Judge has one week in which to deliver a legal judgment. If the Judge fails to deliver a judgment within this time a new Judge is selected. A judgment is delivered by submitting that judgment to the Speaker, who must then distribute that judgment to all players as soon as possible.
|''URL:''|http://www.martinswiki.com/ |
|''Workspace:''|(default)|
|''Description:''|Martin Buddens's Plugins |
|''Author:''|MartinBudden |
|''URL:''|http://mptw.tiddlyspot.com/|
|''Workspace:''|(default)|
|''Description:''|a tiddlywiki distribution and plugins|
|''Author:''|SimonBaird|
Initially rules in the 100's are immutable and rules in the 200's are mutable. Rules subsequently enacted or transmuted (that is, changed from immutable to mutable or vice versa) may be immutable or mutable regardless of their numbers, and rules in the Initial Set may be transmuted regardless of their numbers.
<<rulelist byTag "Mutable">>
<!--{{{-->
<div class='toolbar' macro='toolbar closeTiddler closeOthers +editTiddler > fields syncing permalink references jump'></div>
<div class='title'><span class='rulesmall' macro='view rulenum'></span><span class='rulesmall'>.</span> <span macro='view title'></span> <span class='rulesmall'>Rev. </span><span class='rulesmall' macro='view revnum'></span><span class='rulesmall'> [Mutable]</span></div>
<div class='tagged' macro='tags'></div>
<div class='subtitle'><span macro='view modifier link'></span>, <span macro='view modified date'></span> (<span macro='message views.wikified.createdPrompt'></span> <span macro='view created date'></span>)</div>
<div class='tagging' macro='tagging'></div>
<div class='viewer' macro='view text wikified'></div>
<div class='tagClear'></div>
<!--}}}-->
No rule change may take effect earlier than the moment of the completion of the vote that adopted it, even if its wording explicitly states otherwise. No rule change may have retroactive application.
The Speaker shall give each proposed rule change a number for reference. The numbers shall begin with 301, and each rule change proposed in the proper way shall receive the next successive integer, whether or not the proposal is adopted.
If a rule is repealed and reenacted, it receives the number of the proposal to reenact it. If a rule is amended or transmuted, it receives the number of the proposal to amend or transmute it.
Each Voter has exactly one vote. The Speaker may not vote.
Patheros was the first player to join.
|''URL:''|http://bradleymeck.tiddlyspot.com/|
|''Workspace:''|(default)|
|''Description:''|Resources that are Ripe for the Picking|
|''Author:''|BradleyMeck|
Whatever is not prohibited or regulated by a rule is permitted and unregulated, with the sole exception of changing the rules, which is permitted only when a rule or set of rules explicitly or implicitly permits it.
A player always has the option to forfeit the game rather than continue to play or incur a game penalty. No penalty worse than losing, in the judgment of the player to incur it, may be imposed.
In a conflict between a mutable and an immutable rule, the immutable rule takes precedence and the mutable rule shall be entirely void. For the purposes of this rule a proposal to transmute an immutable rule does not "conflict" with that immutable rule.
|''URL:''|http://ptw.sourceforge.net/ptwe.html|
|''Workspace:''|(default)|
|''Description:''|BramChen's Extensions for TiddlyWiki|
|''Author:''|BramChen|
A proposal shall be made by submitting it to the Speaker. Only Voters may make proposals. As soon as possible after receiving a proposal, the Speaker shall assign the proposal a number and distribute the proposal along with its number to all players. Rule Proposals that enact new Rules must be proposed along with a Rule Name. Rule Proposals that modify existing rules must be proposed along with the name of the Rule they modify.
<!--{{{-->
<div class='toolbar' macro='toolbar +saveCloseTiddler saveTiddler -cancelTiddler cancelCloseTiddler copyTiddler deleteTiddler'></div>
<div class='title'><span macro='view rulenum'></span>-<span macro='view revnum'></span>. <span macro='view title'></span></div>
<div class='editor' macro='edit rulenum'></div>
<div class='editor' macro='edit title'></div>
<div macro='annotations'></div>
<div class='editor' macro='edit text'></div>
<div class='editor' macro='edit tags'></div><div class='editorFooter'><span macro='message views.editor.tagPrompt'></span><span macro='tagChooser'></span></div>
<!--}}}-->
<!--{{{-->
<div class='toolbar' macro='toolbar closeTiddler closeOthers +editTiddler > fields syncing permalink references jump'></div>
<div class='title'><span class='rulesmall' macro='view rulenum'></span><span class='rulesmall'>.</span> <span macro='view title'></span> <span class='rulesmall'> [Proposal]</span></div>
<div class='tagged' macro='tags'></div>
<div class='subtitle'><span macro='view modifier link'></span>, <span macro='view modified date'></span> (<span macro='message views.wikified.createdPrompt'></span> <span macro='view created date'></span>, voting period closes: <span macro='viewfuturedate 604800000'></span>)</div>
<div class='tagging' macro='tagging'></div>
<div class='viewer' macro='view text wikified'></div>
<div class='tagClear'></div>
<!--}}}-->
[[List of Players]]
[[Current Speaker]]
[[List of Voters]]
!Log of Dice Rolls
Random Dice Rolls can be viewed [[here|http://www.sdahl.net/cgi-bin/diceroll?requesttype=viewsession&viewsession=TidNomic]].
!Miscellaneous Public Knowledge
Quorum for a proposed rule change is defined to be 20% of Voters at the beginning of the prescribed voting period for that proposal.
<<showUpdates excludeTag:system>>
Any proposed rule change must be listed at [[Current Proposals]] before it is voted on. If adopted, it must guide play in the form in which it was voted on.
|''URL:''|http://solo.dc3.com/tw/|
|''Workspace:''|(default)|
|''Description:''|Bob Denny's extensions to TiddlyWiki|
|''Author:''|BobDenny|
The required votes for a proposal to be adopted is as follows:
For a proposal which would directly alter the actions which are required of and/or forbidden to the Speaker:
a) a simple majority of all votes legally cast, if the Speaker consents;
b) a 2/3 majority of all votes legally cast, if the Speaker does not consent;
For all other proposals, a simple majority of votes legally cast. This rule defers to rules which set the required number of votes for proposals which propose to transmute a rule.
/***
|''Name:''|RevisionMacro|
|''Version:''|Revision: 1.1.1, 2007-09-1|
|''Author:''|[[Jeff Sheets]]|
This plugin is released under the "Do whatever you like at your own risk" license.
It copies the saveTiddler Command... it will store the previous revision as a separate tiddler, tagged as the current tiddler.
!Code
***/
//{{{
config.commands.saveTiddlerWithRevision = {
text: "revision",
tooltip: "Save changes to this tiddler, and save the previous revision"
}
config.commands.saveTiddlerWithRevision.handler = function(event,src,title)
{
/* take the current contents, and store as an old revision. */
var tiddler = store.fetchTiddler(title);
if (tiddler) {
var srcFields = store.tiddlerExists(title) ? store.fetchTiddler(title).fields : {};
var fields = {};
for (var i in srcFields) {
fields[i] = srcFields[i];
}
var revTitle = title + " Rev. " + (fields.revnum ? fields.revnum : 1);
store.saveTiddler(revTitle,revTitle,tiddler.text,tiddler.modifier,tiddler.modified,"Revision [[" + title + "]]",fields,false,tiddler.created);
}
var newTitle = story.saveTiddler(title,event.shiftKey);
var revnum = store.getValue(title,"revnum");
store.setValue(title,"revnum",Number(revnum ? revnum : 0) + 1);
if(newTitle)
story.displayTiddler(null,newTitle);
return false;
};
//}}}
<!--{{{-->
<div class='toolbar' macro='toolbar closeTiddler closeOthers > +editTiddler fields syncing permalink references jump'></div>
<div class='title'><span macro='view rulenum'></span>. <span macro='view title'></span></div>
<div class='tagged' macro='tags'></div>
<div class='subtitle'><span macro='view modifier link'></span>, <span macro='view modified date'></span> (<span macro='message views.wikified.createdPrompt'></span> <span macro='view created date'></span>)</div>
<div class='tagging' macro='tagging'></div>
<div class='viewer' macro='view text wikified'></div>
<div class='tagClear'></div>
<!--}}}-->
If two or more mutable rules conflict with one another, or if two or more immutable rules conflict with one another, then the rule with the earliest created date takes precedence.
If at least one of the rules in conflict explicitly says of itself that it defers to another rule (or type of rule) or takes precedence over another rule (or type of rule), then such provisions shall supersede the date method for determining precedence.
If two or more rules claim to take precedence over one another or defer to one another, then the date method again governs.
<!--{{{-->
<div class='toolbar' macro='toolbar +saveTiddlerWithRevision saveTiddler -cancelTiddler cancelCloseTiddler copyTiddler deleteTiddler'></div>
<div class='title'><span macro='view rulenum'></span>-<span macro='view revnum'></span>. <span macro='view title'></span></div>
<div class='editor' macro='edit rulenum'></div>
<div class='editor' macro='edit title'></div>
<div macro='annotations'></div>
<div class='editor' macro='edit text'></div>
<div class='editor' macro='edit tags'></div><div class='editorFooter'><span macro='message views.editor.tagPrompt'></span><span macro='tagChooser'></span></div>
<!--}}}-->
A rule change is any of the following: (1) the enactment, repeal, or amendment of a mutable rule; or (2) the transmutation of an immutable rule into a mutable rule or vice versa.
//Note: This definition implies that, at least initially, all new rules are mutable; immutable rules, as long as they are immutable, may not be amended or repealed; mutable rules, as long as they are mutable, may be amended or repealed; any rule of any status may be transmuted; no rule is absolutely immune to change.//
An adopted rule change takes full effect at the moment of the completion of the vote that adopted it.
/***
| Name|SaveCloseTiddlerPlugin|
| Description|Provides two extra toolbar commands, saveCloseTiddler and cancelCloseTiddler|
| Version|3.0 ($Rev: 2134 $)|
| Date|$Date: 2007-04-30 16:11:12 +1000 (Mon, 30 Apr 2007) $|
| Source|http://mptw.tiddlyspot.com/#SaveCloseTiddlerPlugin|
| Author|Simon Baird <simon.baird@gmail.com>|
| License|http://mptw.tiddlyspot.com/#TheBSDLicense|
To use these you must add them to the tool bar in your EditTemplate
***/
//{{{
merge(config.commands,{
saveCloseTiddler: {
text: 'done/close',
tooltip: 'Save changes to this tiddler and close it',
handler: function(e,src,title) {
config.commands.saveTiddler.handler(e,src,title);
config.commands.closeTiddler.handler(e,src,title);
return false;
}
},
cancelCloseTiddler: {
text: 'cancel/close',
tooltip: 'Undo changes to this tiddler and close it',
handler: function(e,src,title) {
config.commands.cancelTiddler.handler(e,src,title);
config.commands.closeTiddler.handler(e,src,title);
return false;
}
}
});
//}}}
Rule changes that affect rules needed to allow or apply rule changes are as permissible as other rule changes. Even rule changes that amend or repeal their own authority are permissible. No rule change or type of move is impermissible solely on account of the self-reference or self-application of a rule.
/***
|Name|ShowUpdatesPlugin|
|Created by|SaqImtiaz|
|Version|0.2 |
|Requires|~TW2.x|
!!!Description:
Allows you to list tiddlers that have changed since the users last visit. You can list only all changed tiddlers, or filter them to only show tiddlers that have or do not have a specific tag. By default a simple list of the titles of changed tiddlers is created. However, using an extremely versatile syntax you can provide a custom template for the generated text.
!!!Examples:
[[ShowUpdatesDocs]]
!!!Installation:
Copy the contents of this tiddler to your TW, tag with systemConfig, save and reload your TW.
!!!Syntax:
{{{<<showUpdates>>}}}
additional optional params:
{{{<showUpdates excludeTag:TagToExclude onlyTag:TagToList maxEntries:10 write:CustomWriteParameter >>}}}
excludeTag: ~TagToExclude
onlyTag: ~TagToList
maxEntries: max number of entries displayed when there are no updates. (default is 10, which can be changed in the config.macros.showUpdates.settings part of the code)
write: if a write parameter is not provided, an un-numbered list of the updates is generated. Alternatively, you can specify a custom 'template' for the text generated. The syntax for the write parameter is identical to that of the forEachTiddler macro. Additonal documentation on this syntax will be provided soon.
Some of the variables available in the write parameter are 'index', 'count' and 'lastVisit' where lastVisit is the date of the last visit in the format YYYYMMDDHHMM. Also areUpdates is a boolean that is true if there are new updates since the users last visit.
!!!To Do:
*refactor code to facilitate translations
*a streamlined version without the custom write parameter
!!!Code
***/
//{{{
window.lewcidLastVisit = '';
window.old_lewcid_whatsnew_restart = window.restart;
window.restart = function()
{
if(config.options.txtLastVisit)
lewcidLastVisit= config.options.txtLastVisit;
config.options.txtLastVisit = (new Date()).convertToYYYYMMDDHHMM();
saveOptionCookie('txtLastVisit');
window.old_lewcid_whatsnew_restart();
}
TiddlyWiki.prototype.lewcidGetTiddlers = function(field,excludeTag,includeTag,updatesOnly)
{
var results = [];
this.forEachTiddler(function(title,tiddler)
{
if(excludeTag == undefined || !tiddler.isTagged(excludeTag))
if(includeTag == undefined || tiddler.isTagged(includeTag))
if ( updatesOnly == false || tiddler.modified.convertToYYYYMMDDHHMM()>lewcidLastVisit)
results.push(tiddler);
});
if(field)
results.sort(function (a,b) {if(a[field] == b[field]) return(0); else return (a[field] < b[field]) ? -1 : +1; });
return results;
}
config.macros.showUpdates={};
config.macros.showUpdates.settings =
{
maxEntries: 10 //max items to show, if there are no updates since last visit
}
config.macros.showUpdates.handler = function(place,macroName,params,wikifier,paramString,tiddler)
{
var args = paramString.parseParams("list",null,true);
var write = getParam(args, "write", undefined);
var onlyTag = getParam(args, "onlyTag", undefined);
var excludeTag = getParam(args, "excludeTag", undefined);
var sortBy = "modified";
var maxEntries = getParam(args,"maxEntries",this.settings.maxEntries);
if (lewcidLastVisit)
{var tiddlers = store.lewcidGetTiddlers(sortBy,excludeTag,onlyTag,true);
var areUpdates = tiddlers.length>0? true:false;}
if (!lewcidLastVisit)
{var countLine = "!!Recent Updates:";
var tiddlers = store.lewcidGetTiddlers(sortBy,excludeTag,onlyTag,false);
var areUpdates = false;}
else if (tiddlers.length == 0)
{var countLine = "!!@@color:red;No new updates@@ since your last visit. @@color:#999;font-size:70%;" + (Date.convertFromYYYYMMDDHHMM(lewcidLastVisit)).formatString(" (DD/MM/YY)") + "@@\n!!Recent Updates:";
var tiddlers = store.lewcidGetTiddlers(sortBy,excludeTag,onlyTag,false);}
else
{var countLine ="!!@@color:red;"+ tiddlers.length + "@@ new " + (tiddlers.length==1?"update":"updates") + " since your last visit: @@color:#999;font-size:70%;" + (Date.convertFromYYYYMMDDHHMM(lewcidLastVisit)).formatString(" (DD/MM/YY)") + "@@";}
tiddlers = tiddlers.reverse();
var lastVisit = lewcidLastVisit? lewcidLastVisit:undefined;
var count = areUpdates == true? tiddlers.length : maxEntries;
var sp = createTiddlyElement(place,"span","showUpdates");
if (write==undefined)
{
wikify(countLine,sp);
var list = createTiddlyElement(sp,"ul");
for (var i = 0; i < count; i++)
{
var tiddler = tiddlers[i];
createTiddlyLink(createTiddlyElement(list,"li"), tiddler.title, true);
}
}
else
{
var list = '';
for (var index = 0; index < count; index++) {
var tiddler = tiddlers[index];
list += eval(write); }
wikify(list, sp);
}
}
//}}}
{{rightalign{
<<simpleclock>>}}}<<search>><<closeAll>><<permaview>><<newTiddler>><<newTiddler label:"new rule" prompt:"Create a new rule tiddler" focus:title text:"Type the text for 'New Rule'" tag:Rule title:"New Rule" fields:{{String.encodeHashMap({revnum:1})}} template:"RuleEditTemplate">><<newTiddler label:"new proposal" prompt:"Create a new proposal tiddler" focus:title text:"Type the text for 'New Proposal'" tag:Proposal title:"New Proposal" template:"ProposalEditTemplate">><<newJournal "DD MMM YYYY">><<saveChanges>><<slider chkSliderOptionsPanel OptionsPanel "options »" "Change TiddlyWiki advanced options">>
/***
|Name|SidebarWithBackstagePlugin|
|Created by|JeffSheets|
|Version|0.1|
|Requires|~TW2.2.4|
!Description:
Hides the Sidebar when the Backstage is hidden, and shows it when the Backstage is shown.
!History
*07-13-07: version 0.1: First Version.
!Code
***/
//{{{
var old_backstage_show = backstage.show
var old_backstage_hide = backstage.hide
backstage.show = function() {
this.area.style.display = "block";
if(anim && config.options.chkAnimate) {
backstage.toolbar.style.left = findWindowWidth() + "px";
var p = [
{style: "left", start: findWindowWidth(), end: 0, template: "%0px"}
];
anim.startAnimating(new Morpher(backstage.toolbar,config.animDuration,p));
} else {
backstage.area.style.left = "0px";
}
this.showButton.style.display = "none";
this.hideButton.style.display = "block";
config.options.chkBackstage = true;
saveOptionCookie("chkBackstage");
addClass(this.content,"backstageVisible");
document.getElementById('sidebar').style.display="block";
document.getElementById('displayArea').style.marginRight="17em";
}
backstage.hide = function() {
if(this.currTabElem) {
this.switchTab(null);
} else {
backstage.toolbar.style.left = "0px";
if(anim && config.options.chkAnimate) {
var p = [
{style: "left", start: 0, end: findWindowWidth(), template: "%0px"}
];
var c = function(element,properties) {backstage.area.style.display = "none";};
anim.startAnimating(new Morpher(backstage.toolbar,config.animDuration,p,c));
} else {
this.area.style.display = "none";
}
this.showButton.style.display = "block";
this.hideButton.style.display = "none";
config.options.chkBackstage = false;
saveOptionCookie("chkBackstage");
removeClass(this.content,"backstageVisible");
document.getElementById('sidebar').style.display="none";
document.getElementById('displayArea').style.marginRight="1em";
}
}
//if(config.options.chkBackstage) {
// document.getElementById('sidebar').style.display="block";
// document.getElementById('displayArea').style.marginRight="18em";
//} else {
// document.getElementById('sidebar').style.display="none";
// document.getElementById('displayArea').style.marginRight="1em";
//}
//}}}
/***
!Metadata:
|''Name:''|SimpleClockPlugin|
|''Description:''||
|''Version:''|1.0.0|
|''Date:''|Apr 16, 2007|
|''Source:''|http://sourceforge.net/project/showfiles.php?group_id=150646|
|''Author:''|BramChen (bram.chen (at) gmail (dot) com)|
|''License:''|[[Creative Commons Attribution-ShareAlike 2.5 License]]|
|''~CoreVersion:''|2.2.0|
|''Browser:''|Firefox 1.5+,IE6,Opera9|
!Usage:
{{{
<<simpleclock scFormat simpleClock>>
}}}
!Revision History:
|''Version''|''Date''|''Note''|
|1.0.0|Apr 16, 2007|Initial release|
|Unofficial|Sept 10, 2007|Unofficial Modification to display the time zone according to CST|
!Code section:
***/
//{{{
version.extensions.simpleclock = {major: 1, minor: 0, revision: 0, date: new Date("Apr 16, 2007")};
if (typeof ptwAddons == "undefined") ptwAddons = {};
merge(ptwAddons, {
simpleClock:{
scFormat:"YYYY-0MM-0DD 0hh:0mm:0ss",
scName: "simpleClock",
scRefresh: function (wrapper,scFormat){
var d = new Date();
var utc = d.getTime() + (d.getTimezoneOffset() * 60000);
var nd = new Date(utc - (3600000*5));
wrapper.innerHTML = nd.formatString(scFormat);
return false;
}
}
});
config.macros.simpleclock = {};
config.macros.simpleclock.handler = function(place,macroName,params){
var scFormat = params[0]?params[0]:ptwAddons.simpleClock.scFormat;
var scName = params[1]?params[1]:ptwAddons.simpleClock.scName;
var wrapper = createTiddlyElement(place,'span',scName,scName);
var scInterval = setInterval(function(){ptwAddons.simpleClock.scRefresh(wrapper,scFormat);},1000);
}
//}}}
a game for rules-lawyers and gaming munchkinism
/***
|''Name:''|SortedListMacro|
|''Version:''|Revision: 1.1.1, 2007-06-21|
|''Author:''|[[Jeff Sheets]]|
This plugin is released under the "Do whatever you like at your own risk" license.
!Code
***/
//{{{
config.macros.rulelist = {};
config.macros.rulelist.handler = function(place,macroName,params)
{
var type = params[0] ? params[0] : "all";
var sortField = params[2] ? params[2] : "rulenum";
var list = document.createElement("ul");
place.appendChild(list);
if(config.macros.list[type].prompt)
createTiddlyElement(list,"li",null,"listTitle",config.macros.list[type].prompt);
var results;
if(config.macros.list[type].handler)
results = config.macros.list[type].handler(params);
results.sort(function(a,b) {
var an = Number(a.fields[sortField]);
var bn = Number(b.fields[sortField]);
return an < bn ? -1 : (an == bn ? 0 : +1);
});
for(var t = 0; t < results.length; t++) {
var li = document.createElement("li");
list.appendChild(li);
li.innerHTML = results[t].fields[sortField] + ". ";
createTiddlyLink(li,typeof results[t] == "string" ? results[t] : results[t].title,true);
}
};
//}}}
In addition to duties which may be listed elsewhere in the rules, the Speaker shall have the following duties:
*register new players
*maintain a list of all players and their public knowledge, and make such a list available to all players
*maintain a complete list of the current rules, and make such a list available to all players
*make a random determination whenever such determination is required by the rules.
/*{{{*/
#mainMenu .tiddlyLinkNonExisting,
#sidebarTabs .tiddlyLinkNonExisting {font-weight:normal; font-style:normal;}
#mainMenu .tiddlyLinkExisting,
#sidebarTabs .tiddlyLinkExisting {font-weight:bold; font-style:normal;}
.headerShadow {position:relative; padding:1em 0em 1em 1em; left:-1px; top:-1px;}
.headerForeground {position:absolute; padding:1em 0em 1em 1em; left:0px; top:0px;}
.leftfloat {float: left; width: 25em; border: 1px solid #000; padding: 1em; margin:0.5em 0.5em 0.1em 0.5em; background: #fff;}
.leftfloat h1:first-child {margin-top:0em;}
.rightfloat {float: right; width: 25em; border: 1px solid #000; padding: 1em; margin: 0.5em 0.5em 0.1em 0.5em; background: #fff;}
.rightfloat h1:first-child {margin-top:0em;}
.leftcolumnfloat {float: left; width: 50%; padding: 0em; background: #fff;}
.rightcolumnfloat {float: right; width: 50%; padding: 0em; background: #fff;}
.clearfloat {clear: both;}
.toolbar {float: right;}
.rightalign {text-align: right;}
.rulesmall {font-size: 80%;}
/*}}}*/
/***
|''Name:''|TaggedList |
|''Version:''|Revision: 1.1.1, 2007-06-21|
|''Author:''|[[Jeff Sheets]]|
This plugin is released under the "Do whatever you like at your own risk" license.
!Example
{{{<<list byTag "systemConfig">>}}} produces:
<<list byTag "systemConfig">>
!Code
***/
//{{{
version.extensions.taggedList = {
major: 1, minor: 1, revision: 1, date: new Date("Jun 21, 2007"), type: 'macro'
};
config.macros.list.byTag = {};
config.macros.list.byTag.prompt = "";
config.macros.list.byTag.handler = function(params) {
var byTag = params[1] ? params[1] : "systemConfig";
return store.reverseLookup("tags",byTag,true,"title");
}
//}}}
/***
|Name|TaggedTemplateTweak|
|Source|http://www.TiddlyTools.com/#TaggedTemplateTweak|
|Version|1.1.0|
|Author|Eric Shulman - ELS Design Studios|
|License|http://www.TiddlyTools.com/#LegalStatements <<br>>and [[Creative Commons Attribution-ShareAlike 2.5 License|http://creativecommons.org/licenses/by-sa/2.5/]]|
|~CoreVersion|2.1|
|Type|plugin|
|Requires||
|Overrides|Story.prototype.chooseTemplateForTiddler()|
|Description|use alternative ViewTemplate/EditTemplate for tiddler's tagged with specific tag values|
The core function, "story.chooseTemplateForTiddler(title,template)" is essentially a "pass-thru" that returns the same template it was given, and is provided by the core so that plugins can customize the template selection logic to select alternative templates, based on whatever programmatic criteria is appropriate. This tweak extends story.chooseTemplateForTiddler() so that ''whenever a tiddler is marked with a specific tag value, it can be viewed and/or edited using alternatives to the standard tiddler templates.''
!!!!!Usage
<<<
Each alternative template is associated with a specific tiddler tag value by using that tag value as a prefix added to the standard TiddlyWiki template titles, [[ViewTemplate]] and [[EditTemplate]].
For example, any tiddlers that are tagged with ''<<tag media>>'' will look for alternative templates named [[mediaViewTemplate]] and [[mediaEditTemplate]]. Additionally, in order to find templates that have proper WikiWord tiddler titles (e.g., [[MediaViewTemplate]] and [[MediaEditTemplate]]), the plugin will also attempt to use a capitalized form of the tag value (e.g., ''Media'') as a prefix. //This capitalization is for comparison purposes only and will not alter the actual tag values that are stored in the tiddler.//
If no matching alternative template can be found by using //any// of the tiddler's tags (either "as-is" or capitalized), the tiddler defaults to using the appropriate standard [[ViewTemplate]] or [[EditTemplate]] definition.
''To add your own custom templates:''
>First, decide upon a suitable tag keyword to uniquely identify your custom templates and create custom view and/or edit templates using that keyword as a prefix (e.g., "KeywordViewTemplate" and "KeywordEditTemplate"). Then, simply create a tiddler and tag it with your chosen keyword... that's it! As long as the tiddler is tagged with your keyword, it will be displayed using the corresponding alternative templates. If you remove the tag or rename/delete the alternative templates, the tiddler will revert to using the standard viewing and editing templates.
<<<
!!!!!Examples
<<<
|Sample tiddler| tag | view template | edit template |
|[[MediaSample - QuickTime]]| <<tag media>> | [[MediaViewTemplate]] | [[MediaEditTemplate]] |
|[[MediaSample - Windows]]| <<tag media>> | [[MediaViewTemplate]] | [[MediaEditTemplate]] |
|[[CDSample]]| <<tag CD>> | [[CDViewTemplate]] | [[CDEditTemplate]] |
|<<newTiddler label:"create new task..." title:SampleTask tag:task text:"Type some text and then press DONE to view the task controls">> | <<tag task>> | [[TaskViewTemplate]] | [[EditTemplate]] |
//(note: if these samples are not present in your document, please visit// http://www.TiddlyTools.com/ //to view these sample tiddlers on-line)//
<<<
!!!!!Installation
<<<
import (or copy/paste) the following tiddlers into your document:
[[TaggedTemplateTweak]]
<<<
!!!!!Revision History
<<<
''2007.06.23 [1.1.0]'' re-written to use automatic 'tag prefix' search instead of hard coded check for each tag. Allows new custom tags to be used without requiring code changes to this plugin.
''2007.06.11 [1.0.0]'' initial release
<<<
!!!!!Credits
<<<
This feature was developed by Eric L Shulman / ELS Design Studios
<<<
!!!!!Code
***/
//{{{
version.extensions.taggedTemplate= {major: 1, minor: 1, revision: 0, date: new Date(2007,6,18)};
Story.prototype.taggedTemplate_chooseTemplateForTiddler = Story.prototype.chooseTemplateForTiddler
Story.prototype.chooseTemplateForTiddler = function(title,template)
{
// get default template from core
var template=this.taggedTemplate_chooseTemplateForTiddler.apply(this,arguments);
// if the tiddler to be rendered doesn't exist yet, just return core result
var tiddler=store.getTiddler(title); if (!tiddler) return template;
// look for template whose prefix matches a tag on this tiddler
for (t=0; t<tiddler.tags.length; t++) {
var tag=tiddler.tags[t];
if (store.tiddlerExists(tag+template)) { template=tag+template; break; }
// try capitalized tag (to match WikiWord template titles)
var cap=tag.substr(0,1).toUpperCase()+tag.substr(1);
if (store.tiddlerExists(cap+template)) { template=cap+template; break; }
}
return template;
}
//}}}
The Speaker for the first game shall be JeffSheets.
If judgment was invoked by a Voter, then the first Judge to be selected to judge that statement shall be the Speaker. If judgment was invoked by the Speaker, the first Judge to be selected shall be a randomly selected Voter.
In all cases, if a Judge beyond the first must be selected to judge a statement, it shall be a randomly selected Voter. The Voter thus selected may not be the player most recently selected as Judge for that statement, nor may e be the player who invoked judgment.
[[In Numerical Order]]
[[Mutable in Numerical Order]]
[[Immutable in Numerical Order]]
[[In Alphabetical Order]]
[[Mutable In Alphabetical Order]]
[[Immutable In Alphabetical Order]]
There must always be at least one mutable rule. The adoption of rule changes must never become completely inpermissible.
TiddlyNomic is a game for rules-lawyers and gaming munchkinism. Not only are the players allowed to change the rules, doing so in a creatively insidious manner is encouraged. Indeed, changing the rules is the only way to win the game.
|''URL:''|http://www.tiddlytools.com/|
|''Workspace:''|(default)|
|''Description:''|Small Tools for Big Ideas!|
|''Author:''|EricShulman|
|''Type:''|file|
|''URL:''|http://www.tiddlywiki.com/|
|''Workspace:''|(default)|
This tiddler was automatically created to record the details of this server
Rule changes that transmute immutable rules into mutable rules may be adopted if and only if the vote is unanimous among votes legally cast. Transmutation shall not be implied, but must be stated explicitly in a proposal to take effect.
/***
|''Name:''|ViewFutureDateMacro|
|''Version:''|Revision: 1.1.1, 2007-09-1|
|''Author:''|[[Jeff Sheets]]|
This plugin is released under the "Do whatever you like at your own risk" license.
This is used to list the end of voting period for proposals. It lists it down to the hour and minute.
!Code
***/
//{{{
config.macros.viewfuturedate = {}
config.macros.viewfuturedate.handler = function(place,macroName,params,wikifier,paramString,tiddler)
{
if((tiddler instanceof Tiddler)) {
var value = store.getValue(tiddler,"created");
if(value != undefined) {
value = Date.convertFromYYYYMMDDHHMM(value);
value = new Date(value.getTime() + (params[0] ? Number(params[0]) : 0));
createTiddlyText(place,value.formatString(params[1] ? params[1] : "YYYY-0MM-0DD 0hh:0mm:0ss"));
}
}
};
//}}}
<!--{{{-->
<div class='toolbar' macro='toolbar closeTiddler closeOthers +editTiddler > fields syncing permalink references jump'></div>
<div class='title' macro='view title'></div>
<div class='tagged' macro='tags'></div>
<div class='subtitle'><span macro='view modifier link'></span>, <span macro='view modified date'></span> (<span macro='message views.wikified.createdPrompt'></span> <span macro='view created date'></span>)</div>
<div class='tagging' macro='tagging'></div>
<div class='viewer' macro='view text wikified'></div>
<div class='tagClear'></div>
<!--}}}-->
|''URL:''|http://visualtw.ouvaton.org/VisualTW.html|
|''Workspace:''|(default)|
|''Author:''|Pascal|
At any time, each player shall be either a Voter or the Speaker; no player may simultaneously be a Voter and a Speaker. At any time there shall be exactly one Speaker. The term "player" in the rules shall specifically include both the Voters and the Speaker.
The prescribed voting period for a proposal shall be one week, beginning at the time the Speaker adds the proposal to this TiddlyWiki.
All rule changes proposed in the proper way shall be voted on. They will be adopted if and only if they receive the [[required number of votes|Required Votes to Pass]] and [[quorum is achieved|Quorum]].
If a player believes that the rules are such that further play is impossible, or that the legality of a move cannot be determined with finality, or that a move appears equally legal and illegal, then the player may invoke judgment on a statement to that effect. If the statement is judged TRUE, then the player who invoked judgment shall be declared the winner of that game, and the game ends, with no provision for starting another game.
This rule takes precedence over every other rule determining the winner of the game.