tiddlywiki 5.1.21 → 5.2.1

package/core/modules/widgets/eventcatcher.js

@@ -0,0 +1,181 @@
+/*\
+title: $:/core/modules/widgets/eventcatcher.js
+type: application/javascript
+module-type: widget
+
+Event handler widget
+
+\*/
+(function(){
+
+/*jslint node: true, browser: true */
+/*global $tw: false */
+"use strict";
+
+var Widget = require("$:/core/modules/widgets/widget.js").widget;
+
+var EventWidget = function(parseTreeNode,options) {
+	this.initialise(parseTreeNode,options);
+};
+
+/*
+Inherit from the base widget class
+*/
+EventWidget.prototype = new Widget();
+
+/*
+Render this widget into the DOM
+*/
+EventWidget.prototype.render = function(parent,nextSibling) {
+	var self = this;
+	// Remember parent
+	this.parentDomNode = parent;
+	// Compute attributes and execute state
+	this.computeAttributes();
+	this.execute();
+	// Create element
+	var tag = this.parseTreeNode.isBlock ? "div" : "span";
+	if(this.elementTag && $tw.config.htmlUnsafeElements.indexOf(this.elementTag) === -1) {
+		tag = this.elementTag;
+	}
+	var domNode = this.document.createElement(tag);
+	this.domNode = domNode;
+	// Assign classes
+	this.assignDomNodeClasses();
+	// Add our event handler
+	$tw.utils.each(this.types,function(type) {
+		domNode.addEventListener(type,function(event) {
+			var selector = self.getAttribute("selector"),
+				actions = self.getAttribute("$"+type) || self.getAttribute("actions-"+type),
+				stopPropagation = self.getAttribute("stopPropagation","onaction"),
+				selectedNode = event.target,
+				selectedNodeRect,
+				catcherNodeRect,
+				variables = {};
+			// Firefox can fire dragover and dragenter events on text nodes instead of their parents
+			if(selectedNode.nodeType === 3) {
+				selectedNode = selectedNode.parentNode;
+			}
+			if(selector) {
+				// Search ancestors for a node that matches the selector
+				while(!$tw.utils.domMatchesSelector(selectedNode,selector) && selectedNode !== domNode) {
+					selectedNode = selectedNode.parentNode;
+				}
+				// If we found one, copy the attributes as variables, otherwise exit
+				if($tw.utils.domMatchesSelector(selectedNode,selector)) {
+					// Only set up variables if we have actions to invoke
+					if(actions) {
+						$tw.utils.each(selectedNode.attributes,function(attribute) {
+							variables["dom-" + attribute.name] = attribute.value.toString();
+						});
+						//Add a variable with a popup coordinate string for the selected node
+						variables["tv-popup-coords"] = "(" + selectedNode.offsetLeft + "," + selectedNode.offsetTop +"," + selectedNode.offsetWidth + "," + selectedNode.offsetHeight + ")";
+
+						//Add variables for offset of selected node
+						variables["tv-selectednode-posx"] = selectedNode.offsetLeft.toString();
+						variables["tv-selectednode-posy"] = selectedNode.offsetTop.toString();
+						variables["tv-selectednode-width"] = selectedNode.offsetWidth.toString();
+						variables["tv-selectednode-height"] = selectedNode.offsetHeight.toString();
+						
+						if(event.clientX && event.clientY) {
+							//Add variables for event X and Y position relative to selected node
+							selectedNodeRect = selectedNode.getBoundingClientRect();
+							variables["event-fromselected-posx"] = (event.clientX - selectedNodeRect.left).toString();
+							variables["event-fromselected-posy"] = (event.clientY - selectedNodeRect.top).toString();
+
+							//Add variables for event X and Y position relative to event catcher node
+							catcherNodeRect = self.domNode.getBoundingClientRect();
+							variables["event-fromcatcher-posx"] = (event.clientX - catcherNodeRect.left).toString();
+							variables["event-fromcatcher-posy"] = (event.clientY - catcherNodeRect.top).toString();
+
+							//Add variables for event X and Y position relative to the viewport
+							variables["event-fromviewport-posx"] = event.clientX.toString();
+							variables["event-fromviewport-posy"] = event.clientY.toString();
+						}
+					}
+				} else {
+					return false;
+				}
+			}
+			// Execute our actions with the variables
+			if(actions) {
+				// Add a variable for the modifier key
+				variables.modifier = $tw.keyboardManager.getEventModifierKeyDescriptor(event);
+				// Add a variable for the mouse button
+				if("button" in event) {
+					if(event.button === 0) {
+						variables["event-mousebutton"] = "left";
+					} else if(event.button === 1) {
+						variables["event-mousebutton"] = "middle";
+					} else if(event.button === 2) {
+						variables["event-mousebutton"] = "right";
+					}
+				}
+				variables["event-type"] = event.type.toString();
+				if(typeof event.detail === "object" && !!event.detail) {
+					$tw.utils.each(event.detail,function(detailValue,detail) {
+						variables["event-detail-" + detail] = detailValue.toString();
+					});
+				} else if(!!event.detail) {
+					variables["event-detail"] = event.detail.toString();
+				}
+				self.invokeActionString(actions,self,event,variables);
+			}
+			if((actions && stopPropagation === "onaction") || stopPropagation === "always") {
+				event.preventDefault();
+				event.stopPropagation();
+				return true;
+			}
+			return false;
+		},false);
+	});
+	// Insert element
+	parent.insertBefore(domNode,nextSibling);
+	this.renderChildren(domNode,null);
+	this.domNodes.push(domNode);
+};
+
+/*
+Compute the internal state of the widget
+*/
+EventWidget.prototype.execute = function() {
+	var self = this;
+	// Get attributes that require a refresh on change
+	this.types = [];
+	$tw.utils.each(this.attributes,function(value,key) {
+		if(key.charAt(0) === "$") {
+			self.types.push(key.slice(1));
+		}
+	});
+	if(!this.types.length) {
+		this.types = this.getAttribute("events","").split(" ");
+	}
+	this.elementTag = this.getAttribute("tag");
+	// Make child widgets
+	this.makeChildWidgets();
+};
+
+EventWidget.prototype.assignDomNodeClasses = function() {
+	var classes = this.getAttribute("class","").split(" ");
+	classes.push("tc-eventcatcher");
+	this.domNode.className = classes.join(" ");
+};
+
+/*
+Selectively refreshes the widget if needed. Returns true if the widget or any of its children needed re-rendering
+*/
+EventWidget.prototype.refresh = function(changedTiddlers) {
+	var changedAttributes = this.computeAttributes(),
+		changedAttributesCount = $tw.utils.count(changedAttributes);
+	if(changedAttributesCount === 1 && changedAttributes["class"]) {
+		this.assignDomNodeClasses();
+	} else if(changedAttributesCount > 0) {
+		this.refreshSelf();
+		return true;
+	}
+	return this.refreshChildren(changedTiddlers);
+};
+
+exports.eventcatcher = EventWidget;
+
+})();

package/core/modules/widgets/fieldmangler.js

@@ -16,12 +16,6 @@ var Widget = require("$:/core/modules/widgets/widget.js").widget;
 
 var FieldManglerWidget = function(parseTreeNode,options) {
 	this.initialise(parseTreeNode,options);
-	this.addEventListeners([
-		{type: "tm-remove-field", handler: "handleRemoveFieldEvent"},
-		{type: "tm-add-field", handler: "handleAddFieldEvent"},
-		{type: "tm-remove-tag", handler: "handleRemoveTagEvent"},
-		{type: "tm-add-tag", handler: "handleAddTagEvent"}
-	]);
 };
 
 /*
@@ -33,6 +27,12 @@ FieldManglerWidget.prototype = new Widget();
 Render this widget into the DOM
 */
 FieldManglerWidget.prototype.render = function(parent,nextSibling) {
+	this.addEventListeners([
+		{type: "tm-remove-field", handler: "handleRemoveFieldEvent"},
+		{type: "tm-add-field", handler: "handleAddFieldEvent"},
+		{type: "tm-remove-tag", handler: "handleRemoveTagEvent"},
+		{type: "tm-add-tag", handler: "handleAddTagEvent"}
+	]);
 	this.parentDomNode = parent;
 	this.computeAttributes();
 	this.execute();
@@ -58,7 +58,7 @@ FieldManglerWidget.prototype.refresh = function(changedTiddlers) {
 		this.refreshSelf();
 		return true;
 	} else {
-		return this.refreshChildren(changedTiddlers);		
+		return this.refreshChildren(changedTiddlers);
 	}
 };
 
@@ -67,32 +67,18 @@ FieldManglerWidget.prototype.handleRemoveFieldEvent = function(event) {
 		deletion = {};
 	deletion[event.param] = undefined;
 	this.wiki.addTiddler(new $tw.Tiddler(tiddler,deletion));
-	return true;
+	return false;
 };
 
 FieldManglerWidget.prototype.handleAddFieldEvent = function(event) {
 	var tiddler = this.wiki.getTiddler(this.mangleTitle),
 		addition = this.wiki.getModificationFields(),
-		hadInvalidFieldName = false,
 		addField = function(name,value) {
-			var trimmedName = name.toLowerCase().trim();
-			if(!$tw.utils.isValidFieldName(trimmedName)) {
-				if(!hadInvalidFieldName) {
-					alert($tw.language.getString(
-						"InvalidFieldName",
-						{variables:
-							{fieldName: trimmedName}
-						}
-					));
-					hadInvalidFieldName = true;
-					return;
-				}
-			} else {
-				if(!value && tiddler) {
-					value = tiddler.fields[trimmedName];
-				}
-				addition[trimmedName] = value || "";
+			var trimmedName = name.trim();
+			if(!value && tiddler) {
+				value = tiddler.fields[trimmedName];
 			}
+			addition[trimmedName] = value || "";
 			return;
 		};
 	addition.title = this.mangleTitle;
@@ -105,7 +91,7 @@ FieldManglerWidget.prototype.handleAddFieldEvent = function(event) {
 		}
 	}
 	this.wiki.addTiddler(new $tw.Tiddler(tiddler,addition));
-	return true;
+	return false;
 };
 
 FieldManglerWidget.prototype.handleRemoveTagEvent = function(event) {
@@ -122,7 +108,7 @@ FieldManglerWidget.prototype.handleRemoveTagEvent = function(event) {
 			this.wiki.addTiddler(new $tw.Tiddler(tiddler,modification));
 		}
 	}
-	return true;
+	return false;
 };
 
 FieldManglerWidget.prototype.handleAddTagEvent = function(event) {
@@ -133,14 +119,14 @@ FieldManglerWidget.prototype.handleAddTagEvent = function(event) {
 		if(tag !== "") {
 			modification.tags = (tiddler.fields.tags || []).slice(0);
 			$tw.utils.pushTop(modification.tags,tag);
-			this.wiki.addTiddler(new $tw.Tiddler(tiddler,modification));			
+			this.wiki.addTiddler(new $tw.Tiddler(tiddler,modification));
 		}
 	} else if(typeof event.param === "string" && event.param.trim() !== "" && this.mangleTitle.trim() !== "") {
 		var tag = [];
 		tag.push(event.param.trim());
 		this.wiki.addTiddler(new $tw.Tiddler({title: this.mangleTitle, tags: tag},modification));
 	}
-	return true;
+	return false;
 };
 
 exports.fieldmangler = FieldManglerWidget;

package/core/modules/widgets/fields.js

@@ -42,44 +42,53 @@ FieldsWidget.prototype.execute = function() {
 	// Get parameters from our attributes
 	this.tiddlerTitle = this.getAttribute("tiddler",this.getVariable("currentTiddler"));
 	this.template = this.getAttribute("template");
+	this.sort = this.getAttribute("sort","yes") === "yes";
+	this.sortReverse = this.getAttribute("sortReverse","no") === "yes";
 	this.exclude = this.getAttribute("exclude");
+	this.include = this.getAttribute("include",null);
 	this.stripTitlePrefix = this.getAttribute("stripTitlePrefix","no") === "yes";
 	// Get the value to display
 	var tiddler = this.wiki.getTiddler(this.tiddlerTitle);
-	// Get the exclusion list
-	var exclude;
-	if(this.exclude) {
-		exclude = this.exclude.split(" ");
-	} else {
-		exclude = ["text"]; 
-	}
+
+	// Get the inclusion and exclusion list
+	var excludeArr = (this.exclude) ? this.exclude.split(" ") : ["text"];
+	// Include takes precedence
+	var includeArr = (this.include) ? this.include.split(" ") : null;
+
 	// Compose the template
 	var text = [];
 	if(this.template && tiddler) {
 		var fields = [];
-		for(var fieldName in tiddler.fields) {
-			if(exclude.indexOf(fieldName) === -1) {
-				fields.push(fieldName);
+		if (includeArr) { // Include takes precedence
+			for(var i=0; i<includeArr.length; i++) {
+				if(tiddler.fields[includeArr[i]]) {
+					fields.push(includeArr[i]);
+				}
+			}
+		} else {
+			for(var fieldName in tiddler.fields) {
+				if(excludeArr.indexOf(fieldName) === -1) {
+					fields.push(fieldName);
+				}
 			}
 		}
-		fields.sort();
-		for(var f=0; f<fields.length; f++) {
+		if (this.sort) fields.sort();
+		if (this.sortReverse) fields.reverse();
+		for(var f=0, fmax=fields.length; f<fmax; f++) {
 			fieldName = fields[f];
-			if(exclude.indexOf(fieldName) === -1) {
-				var row = this.template,
-					value = tiddler.getFieldString(fieldName);
-				if(this.stripTitlePrefix && fieldName === "title") {
-					var reStrip = /^\{[^\}]+\}(.+)/mg,
-						reMatch = reStrip.exec(value);
-					if(reMatch) {
-						value = reMatch[1];
-					}
+			var row = this.template,
+				value = tiddler.getFieldString(fieldName);
+			if(this.stripTitlePrefix && fieldName === "title") {
+				var reStrip = /^\{[^\}]+\}(.+)/mg,
+					reMatch = reStrip.exec(value);
+				if(reMatch) {
+					value = reMatch[1];
 				}
-				row = $tw.utils.replaceString(row,"$name$",fieldName);
-				row = $tw.utils.replaceString(row,"$value$",value);
-				row = $tw.utils.replaceString(row,"$encoded_value$",$tw.utils.htmlEncode(value));
-				text.push(row);
 			}
+			row = $tw.utils.replaceString(row,"$name$",fieldName);
+			row = $tw.utils.replaceString(row,"$value$",value);
+			row = $tw.utils.replaceString(row,"$encoded_value$",$tw.utils.htmlEncode(value));
+			text.push(row);
 		}
 	}
 	this.text = text.join("");
@@ -90,11 +99,13 @@ Selectively refreshes the widget if needed. Returns true if the widget or any of
 */
 FieldsWidget.prototype.refresh = function(changedTiddlers) {
 	var changedAttributes = this.computeAttributes();
-	if(changedAttributes.tiddler || changedAttributes.template || changedAttributes.exclude || changedAttributes.stripTitlePrefix || changedTiddlers[this.tiddlerTitle]) {
-		this.refreshSelf();
-		return true;
+	if( changedAttributes.tiddler || changedAttributes.template || changedAttributes.exclude ||
+		changedAttributes.include || changedAttributes.sort || changedAttributes.sortReverse ||
+		changedTiddlers[this.tiddlerTitle] || changedAttributes.stripTitlePrefix) {
+			this.refreshSelf();
+			return true;
 	} else {
-		return false;	
+		return false;
 	}
 };
 

package/core/modules/widgets/image.js

@@ -86,7 +86,7 @@ ImageWidget.prototype.render = function(parent,nextSibling) {
 					default:
 						src = _canonical_uri;
 						break;
-				}	
+				}
 			} else {
 				// Just trigger loading of the tiddler
 				this.wiki.getTiddlerText(this.imageSource);
@@ -97,7 +97,7 @@ ImageWidget.prototype.render = function(parent,nextSibling) {
 	var domNode = this.document.createElement(tag);
 	domNode.setAttribute("src",src);
 	if(this.imageClass) {
-		domNode.setAttribute("class",this.imageClass);		
+		domNode.setAttribute("class",this.imageClass);
 	}
 	if(this.imageWidth) {
 		domNode.setAttribute("width",this.imageWidth);
@@ -106,10 +106,10 @@ ImageWidget.prototype.render = function(parent,nextSibling) {
 		domNode.setAttribute("height",this.imageHeight);
 	}
 	if(this.imageTooltip) {
-		domNode.setAttribute("title",this.imageTooltip);		
+		domNode.setAttribute("title",this.imageTooltip);
 	}
 	if(this.imageAlt) {
-		domNode.setAttribute("alt",this.imageAlt);		
+		domNode.setAttribute("alt",this.imageAlt);
 	}
 	// Insert element
 	parent.insertBefore(domNode,nextSibling);
@@ -138,7 +138,7 @@ ImageWidget.prototype.refresh = function(changedTiddlers) {
 		this.refreshSelf();
 		return true;
 	} else {
-		return false;		
+		return false;
 	}
 };
 

package/core/modules/widgets/importvariables.js

@@ -37,49 +37,61 @@ ImportVariablesWidget.prototype.render = function(parent,nextSibling) {
 Compute the internal state of the widget
 */
 ImportVariablesWidget.prototype.execute = function(tiddlerList) {
-	var self = this;
+	var widgetPointer = this;
+	// Got to flush all the accumulated variables
+	this.variables = new this.variablesConstructor();
 	// Get our parameters
 	this.filter = this.getAttribute("filter");
 	// Compute the filter
 	this.tiddlerList = tiddlerList || this.wiki.filterTiddlers(this.filter,this);
 	// Accumulate the <$set> widgets from each tiddler
-	var widgetStackStart,widgetStackEnd;
-	function addWidgetNode(widgetNode) {
-		if(widgetNode) {
-			if(!widgetStackStart && !widgetStackEnd) {
-				widgetStackStart = widgetNode;
-				widgetStackEnd = widgetNode;
-			} else {
-				widgetStackEnd.children = [widgetNode];
-				widgetStackEnd = widgetNode;
-			}
-		}
-	}
 	$tw.utils.each(this.tiddlerList,function(title) {
-		var parser = self.wiki.parseTiddler(title);
+		var parser = widgetPointer.wiki.parseTiddler(title);
 		if(parser) {
 			var parseTreeNode = parser.tree[0];
 			while(parseTreeNode && parseTreeNode.type === "set") {
-				addWidgetNode({
+				var node = {
 					type: "set",
 					attributes: parseTreeNode.attributes,
 					params: parseTreeNode.params,
 					isMacroDefinition: parseTreeNode.isMacroDefinition
-				});
-				parseTreeNode = parseTreeNode.children[0];
+				};
+				if (parseTreeNode.isMacroDefinition) {
+					// Macro definitions can be folded into
+					// current widget instead of adding
+					// another link to the chain.
+					var widget = widgetPointer.makeChildWidget(node);
+					widget.computeAttributes();
+					widget.execute();
+					// We SHALLOW copy over all variables
+					// in widget. We can't use
+					// $tw.utils.assign, because that copies
+					// up the prototype chain, which we
+					// don't want.
+					$tw.utils.each(Object.keys(widget.variables), function(key) {
+						widgetPointer.variables[key] = widget.variables[key];
+					});
+				} else {
+					widgetPointer.children = [widgetPointer.makeChildWidget(node)];
+					// No more regenerating children for
+					// this widget. If it needs to refresh,
+					// it'll do so along with the the whole
+					// importvariable tree.
+					if (widgetPointer != this) {
+						widgetPointer.makeChildWidgets = function(){};
+					}
+					widgetPointer = widgetPointer.children[0];
+				}
+				parseTreeNode = parseTreeNode.children && parseTreeNode.children[0];
 			}
 		} 
 	});
-	// Add our own children to the end of the pile
-	var parseTreeNodes;
-	if(widgetStackStart && widgetStackEnd) {
-		parseTreeNodes = [widgetStackStart];
-		widgetStackEnd.children = this.parseTreeNode.children;
+
+	if (widgetPointer != this) {
+		widgetPointer.parseTreeNode.children = this.parseTreeNode.children;
 	} else {
-		parseTreeNodes = this.parseTreeNode.children;
+		widgetPointer.makeChildWidgets();
 	}
-	// Construct the child widgets
-	this.makeChildWidgets(parseTreeNodes);
 };
 
 /*
@@ -106,7 +118,7 @@ ImportVariablesWidget.prototype.refresh = function(changedTiddlers) {
 		this.renderChildren(this.parentDomNode,this.findNextSiblingDomNode());
 		return true;
 	} else {
-		return this.refreshChildren(changedTiddlers);		
+		return this.refreshChildren(changedTiddlers);
 	}
 };
 

package/core/modules/widgets/jsontiddler.js

@@ -0,0 +1,91 @@
+/*\
+title: $:/core/modules/widgets/jsontiddler.js
+type: application/javascript
+module-type: widget
+
+Render a tiddler as JSON text
+
+\*/
+(function(){
+
+/*jslint node: true, browser: true */
+/*global $tw: false */
+"use strict";
+
+var Widget = require("$:/core/modules/widgets/widget.js").widget;
+
+var JSONTiddlerWidget = function(parseTreeNode,options) {
+	this.initialise(parseTreeNode,options);
+};
+
+/*
+Inherit from the base widget class
+*/
+JSONTiddlerWidget.prototype = new Widget();
+
+/*
+Render this widget into the DOM
+*/
+JSONTiddlerWidget.prototype.render = function(parent,nextSibling) {
+	var self = this;
+	this.parentDomNode = parent;
+	this.computeAttributes();
+	this.execute();
+	// Collect the fields from the optional base tiddler
+	var fields = this.getTiddlerFields();
+	// Add custom fields specified in attributes starting with $
+	$tw.utils.each(this.attributes,function(attribute,name) {
+		if(name.charAt(0) === "$") {
+			fields[name.slice(1)] = attribute;
+		}
+	});
+	// JSONify
+	var json = JSON.stringify(fields);
+	// Escape unsafe script characters
+	if(this.attEscapeUnsafeScriptChars) {
+		json = json.replace(/</g,"\\u003C");
+	}
+	// Update the DOM
+	var textNode = this.document.createTextNode(json);
+	parent.insertBefore(textNode,nextSibling);
+	this.domNodes.push(textNode);
+};
+
+/*
+Compute the internal state of the widget
+*/
+JSONTiddlerWidget.prototype.execute = function() {
+	this.attTiddler = this.getAttribute("tiddler");
+	this.attExclude = this.getAttribute("exclude","");
+	this.attEscapeUnsafeScriptChars = this.getAttribute("escapeUnsafeScriptChars","no") === "yes";
+};
+
+/*
+Selectively refreshes the widget if needed. Returns true if the widget or any of its children needed re-rendering
+*/
+JSONTiddlerWidget.prototype.refresh = function(changedTiddlers) {
+	var changedAttributes = this.computeAttributes();
+	if($tw.utils.count(changedAttributes) > 0 || (this.attTiddler && changedTiddlers[this.attTiddler])) {
+		this.refreshSelf();
+		return true;
+	} else {
+		return false;
+	}
+};
+
+JSONTiddlerWidget.prototype.getTiddlerFields = function() {
+	var fields = {};
+	if(this.attTiddler) {
+		var tiddler = this.wiki.getTiddler(this.attTiddler);
+		if(tiddler) {
+			fields = tiddler.getFieldStrings({exclude: this.attExclude.split(" ")});
+		} else {
+			fields = {title: this.attTiddler};
+		}
+	}
+	return fields;
+};
+
+exports.jsontiddler = JSONTiddlerWidget;
+
+})();