tw5-graph 1.7.1

package/plugins/graph/widgets/fieldtranscriber.js

@@ -0,0 +1,98 @@
+/*\
+
+Widget for transcribing the text of one data tiddler
+into the field of another. and vice-versa.
+
+\*/
+
+"use strict";
+
+var Widget = require("$:/core/modules/widgets/widget.js").widget;
+
+var Scribers = $tw.modules.getModulesByTypeAsHashmap("fieldtranscribertype");
+
+var ScriberWidget = function(parseTreeNode, options) {
+	this.initialise(parseTreeNode, options);
+};
+
+ScriberWidget.prototype = new Widget();
+
+ScriberWidget.prototype.render = function(parent, nextSibling) {
+	this.parentDomNode = parent;
+	this.computeAttributes();
+	this.execute();
+	this.renderChildren(parent, nextSibling);
+};
+
+ScriberWidget.prototype.execute = function() {
+	this.scribeField = this.getAttribute("field");
+	this.scribeTiddler = this.getAttribute("tiddler") || (!this.hasParseTreeNodeAttribute("tiddler") && this.getVariable("currentTiddler"));
+	this.scribeType = this.getAttribute("type");
+	this.scribeState = this.getAttribute("state");
+	if (!this.scribeState) {
+		this.scribeState = "$:/temp/flibbles/graph/fieldtranscriber/" + encodeURIComponent(this.scribeField) + "/" + this.scribeTiddler;
+	}
+	if (!Scribers[this.scribeType]) {
+		this.scribeType = "text/plain";
+	}
+	this.setVariable("state", this.scribeState);
+	this.transcriber = Scribers[this.scribeType];
+	this.prepState();
+	this.makeChildWidgets();
+};
+
+ScriberWidget.prototype.refresh = function(changedTiddlers) {
+	var changedAttributes = this.computeAttributes();
+	if ($tw.utils.count(changedAttributes) > 0) {
+		this.refreshSelf();
+		return true;
+	}
+	if (changedTiddlers[this.scribeState] && this.scribeField) {
+		// Our tracked state has changed. Time to transcribe.
+		var state = this.wiki.getTiddler(this.scribeState);
+		if (state) {
+			var stateText = state.getFieldString("text");
+			if (this.stateText !== stateText) {
+				var fieldText = this.transcriber.toField(stateText);
+				if (fieldText !== this.fieldText) {
+					this.wiki.setText(this.scribeTiddler, this.scribeField, null, fieldText);
+					this.fieldText = fieldText;
+					this.stateText = stateText;
+				}
+			}
+		} else {
+			this.wiki.setText(this.scribeTiddler, this.scribeField, null, undefined);
+			this.fieldText = undefined;
+			this.stateText = undefined;
+		}
+	}
+	if (changedTiddlers[this.scribeTiddler]) {
+		this.prepState();
+	}
+	return this.refreshChildren(changedTiddlers);
+};
+
+ScriberWidget.prototype.prepState = function() {
+	if (this.scribeState && this.scribeField) {
+		var tiddler = this.wiki.getTiddler(this.scribeTiddler);
+		if (tiddler) {
+			var fieldText = tiddler.fields[this.scribeField];
+			if (this.fieldText !== fieldText) {
+				this.fieldText = fieldText;
+				if (fieldText === undefined) {
+					this.wiki.deleteTiddler(this.scribeState);
+					this.stateText = undefined;
+				} else {
+					this.stateText = this.transcriber.fromField(fieldText);
+					this.wiki.addTiddler({
+						title: this.scribeState,
+						text: this.stateText,
+						type: this.scribeType
+					});
+				}
+			}
+		}
+	}
+};
+
+exports.fieldtranscriber = ScriberWidget;

package/plugins/graph/widgets/graphobject.js

@@ -0,0 +1,154 @@
+/*\
+
+Base-class widget that provides standard functionality for all "graph objects",
+such as nodes or edges.
+
+\*/
+
+"use strict";
+
+var Widget = require("$:/core/modules/widgets/widget.js").widget;
+var utils = require("../utils.js");
+
+var ObjectWidget = function(parseTreeNode, options) {};
+
+ObjectWidget.prototype = new Widget();
+
+// Graph object widgets are a type of property holder.
+Object.assign(ObjectWidget.prototype, utils.PropertyHolder);
+
+ObjectWidget.prototype.render = function(parent, nextSibling) {
+	this.parentDomNode = parent;
+	this.parentPropertiesWidget = utils.getParentProperties(this, this.graphObjectType);
+	this.computeAttributes();
+	this.execute();
+	this.computeParents();
+	this.renderChildren(parent, nextSibling);
+};
+
+ObjectWidget.prototype.refresh = function(changedTiddlers) {
+	var changedAttributes = this.computeAttributes();
+	// Did our parents experience a change to their properties?
+	if (this.computeParents()
+	// Did our own property attribute change obviously?
+	|| $tw.utils.count(changedAttributes) > 0
+	// Were the properties cleared because they were stale?
+	|| !this.properties
+	// maybe properties changed covertly... (expensive)
+	|| this.refreshProperties(changedTiddlers)) {
+		this.execute();
+		// They'll need to be refreshed
+		this.properties = null;
+	}
+	// Then we give our children a chance to refresh too
+	return this.refreshChildren(changedTiddlers) || !this.properties;
+};
+
+ObjectWidget.prototype.allowActionPropagation = function() {
+	return false;
+};
+
+/*
+Can be overriden to allow object types to set properties based on rules
+and behaviors specific to that typeA.
+*/
+ObjectWidget.prototype.setCustomProperties = function(properties, rules) {};
+
+/*
+This is an opportunity for a graphObject to evaluate itself in relation with
+all other collected graph objects, as well as knowing its own relative index.
+It can use this opportunity to flag itself as needing refreshing, or
+return true to indicate it should be pruned away as an illegal object.
+*/
+ObjectWidget.prototype.curate = function(objects, index) { return false; };
+
+/*
+Calculates and stores the properties raw values in the object.
+Then returns the evaluated property values to be used by the engine.
+*/
+ObjectWidget.prototype.calculatePropertyValues = function(rules) {
+	return this.evaluateProperties(this.computeProperties(rules), rules);
+};
+
+/*
+Computes the properties for this object and returns them in an object.
+*/
+ObjectWidget.prototype.computeProperties = function(rules) {
+	var newProperties = Object.create(null);
+	// First, we set any auto-properties, so that anything else
+	// will have the opportunity to override them.
+	for (var name in rules) {
+		var property = rules[name];
+		// It's flagged to always be sent to the engine.
+		// Send along the default value. It may be overridden momentarily.
+		if (property.always) {
+			newProperties[name] = property.default;
+		}
+	}
+	// Then we travel down and set properties based on containing
+	// $property widgets.
+	for (var i = this.applicableParents.length-1; i >= 0; i--) {
+		var widget = this.applicableParents[i];
+		for (var property in widget.properties) {
+			newProperties[property] = widget.properties[property];
+		}
+	}
+	// Then object types get a chance to set properties based on
+	// their own unique rules.
+	this.setCustomProperties(newProperties, rules);
+	// Then we set properties based on explicit attributes
+	// on this object. These take highest priority.
+	for (var key in this.attributes) {
+		if (key.charAt(0) !== "$") {
+			var value = this.attributes[key];
+			if (value) {
+				newProperties[key] = this.attributes[key];
+			}
+		}
+	}
+	return newProperties;
+};
+
+ObjectWidget.prototype.catchGraphEvent = function(graphEvent, triggeringWidget, variables) {
+	var actions = this.attributes[graphEvent.type];
+	if (actions) {
+		triggeringWidget.invokeActionString(actions, triggeringWidget, graphEvent.event, variables);
+		return true;
+	}
+	return false;
+};
+
+ObjectWidget.prototype.computeParents = function() {
+	var index = 0;
+	var changed = false;
+	var list = this.applicableParents = this.applicableParents || [];
+	this.traversePropertyWidgets(function(widget) {
+		if (list[index] !== widget) {
+			list[index] = widget;
+			changed = true;
+		} else if (widget.propertiesChanged) {
+			changed = true;
+		}
+		index++;
+	});
+	if (index !== list.length) {
+		list.length = index;
+		changed = true;
+	}
+	return changed;
+};
+
+/**
+ * Explore for any $properties which might apply to this. Can be overridden.
+ */
+ObjectWidget.prototype.traversePropertyWidgets = function(method) {
+	var widget = this.parentPropertiesWidget;
+	while (widget !== null) {
+		if (widget.filterFunc([this.id], widget).length > 0) {
+			method(widget);
+		}
+		widget = widget.parentPropertiesWidget;
+	}
+};
+
+exports.graphobject = ObjectWidget;

package/plugins/graph/widgets/messagerelay.js

@@ -0,0 +1,115 @@
+/*\
+
+Widget for relaying emitted messages to other parts of the widget.
+This allows buttons for a graph to exist outside of that graph.
+
+\*/
+
+"use strict";
+
+var Widget = require("$:/core/modules/widgets/widget.js").widget;
+var utils = require("../utils.js");
+
+// Relayed is used to avoid infinite loops. Once an event is relayed,
+// it puts itself in this object under the relay name, so it can't be
+// relayed again through that name
+var relayed = Object.create(null);
+
+var RelayWidget = function(parseTreeNode, options) {
+	this.initialise(parseTreeNode, options);
+	utils.registerForGarbageCollection(this);
+};
+
+RelayWidget.prototype = new Widget();
+
+RelayWidget.prototype.render = function(parent, nextSibling) {
+	this.parentDomNode = parent;
+	this.computeAttributes();
+	this.execute();
+	this.renderChildren(parent, nextSibling);
+};
+
+RelayWidget.prototype.execute = function() {
+	this.relayName = this.getAttribute("name");
+	this.relayTo = this.getAttribute("to");
+	if (this.relayName) {
+		var register = this.wiki.relayRegister = this.wiki.relayRegister || Object.create(null);
+		register[this.relayName] = register[this.relayName] || [];
+		register[this.relayName].push(this);
+	}
+	this.makeChildWidgets();
+};
+
+RelayWidget.prototype.refresh = function(changedTiddlers) {
+	var changedAttributes = this.computeAttributes();
+	var changed = false;
+	if (changedAttributes.name) {
+		this.garbageCollect();
+		this.refreshSelf();
+		return true;
+	}
+	if (changedAttributes.to) {
+		this.relayTo = this.getAttribute("to");
+		changed = true;
+	}
+	return this.refreshChildren(changedTiddlers) || changed;
+};
+
+RelayWidget.prototype.dispatchEvent = function(event) {
+	var register = this.wiki.relayRegister;
+	if (this.relayTo
+	&& register
+	&& register[this.relayTo]
+	&& relayed[this.relayTo] !== event) {
+		relayed[this.relayTo] = event;
+		var targets = register[this.relayTo];
+		for (var i = 0; i < targets.length; i++) {
+			var target = targets[i];
+			if (!target.isGarbage()) {
+				targets[i].dispatchEvent(event);
+			}
+		}
+	} else {
+		return Widget.prototype.dispatchEvent.call(this, event);
+	}
+};
+
+RelayWidget.prototype.isGarbage = function() {
+	var root = rootWidget(this);
+	return root !== $tw.rootWidget;
+};
+
+RelayWidget.prototype.garbageCollect = function() {
+	if (this.relayName) {
+		var register = this.wiki.relayRegister[this.relayName];
+		for (var i = 0; i < register.length; i++) {
+			if (register[i] === this) {
+				// Remove this from the register
+				register.splice(i, 1);
+			}
+		}
+		this.relayName = undefined;
+	}
+};
+
+function rootWidget(relay) {
+	var parent = relay.parentWidget;
+	while (parent) {
+		var i = 0;
+		for (; i < parent.children.length; i++) {
+			if (parent.children[i] === relay) {
+				// Confirmed that the parent still owns this child
+				break;
+			}
+		}
+		if (i == parent.children.length) {
+			// Ownership was not confirmed
+			return null;
+		}
+		relay = parent;
+		parent = relay.parentWidget;
+	}
+	return relay;
+};
+
+exports.messagerelay = RelayWidget;

package/plugins/graph/widgets/properties.js

@@ -0,0 +1,130 @@
+/*\
+
+Widget for setting properties on graph objects.
+
+\*/
+
+"use strict";
+
+var Widget = require("$:/core/modules/widgets/widget.js").widget;
+var utils = require("../utils.js");
+var Engines = $tw.modules.getModulesByTypeAsHashmap("graphengine");
+var PropertyTypes = $tw.modules.getModulesByTypeAsHashmap("graphpropertytype");
+
+var Properties = function(parseTreeNode, options) {
+	this.initialise(parseTreeNode, options);
+};
+
+Properties.prototype = new Widget();
+
+Properties.prototype.graphPropertiesWidget = true;
+
+Properties.prototype.render = function(parent, nextSibling) {
+	this.parentDomNode = parent;
+	this.computeAttributes();
+	this.execute();
+	this.renderChildren(parent, nextSibling);
+};
+
+Properties.prototype.execute = function() {
+	this.type = this.getAttribute("$for", "nodes");
+	this.parentPropertiesWidget = utils.getParentProperties(this, this.type);
+	this.filter = this.getAttribute("$filter");
+	this.properties = this.getProperties();
+	this.filterFunc = this.filter? this.wiki.compileFilter(this.filter): function(source) { return source; };
+	this.makeChildWidgets();
+};
+
+Properties.prototype.refresh = function(changedTiddlers) {
+	var changedAttributes = this.computeAttributes();
+	this.propertiesChanged = false;
+	if (changedAttributes["$for"]) {
+		// If the $for changed, we need to refocus to the different object type.
+		this.refreshSelf();
+		return true;
+	}
+	if (propertiesChanged(changedAttributes)
+	|| changedAttributes["$tiddler"]
+	|| changedAttributes["$field"]
+	|| (this.dataTiddler
+		&& changedTiddlers[this.dataTiddler]
+		&& this.rawData !== getTiddlerString(this.wiki, this.dataTiddler, this.field))) {
+		// Our styling attributes have changed, so everything this $style
+		// affects needs to refresh.
+		this.properties = this.getProperties();
+		this.propertiesChanged = true;
+	}
+	// If we have a filterFunc, we need to worry about whether this style
+	// applies to a different subset of its children objects or not.
+	if (changedAttributes["$filter"]) {
+		this.filter = this.getAttribute("$filter");
+		this.filterFunc = this.filter? this.wiki.compileFilter(this.filter): function(source) { return source; };
+	}
+	return this.refreshChildren(changedTiddlers) || this.propertiesChanged;
+};
+
+Properties.prototype.getProperties = function() {
+	this.field = this.getAttribute("$field");
+	this.dataTiddler = this.getAttribute("$tiddler");
+	if (!this.dataTiddler && this.field) {
+		this.dataTiddler = this.getVariable("currentTiddler");
+	}
+	var styleObject = Object.create(null);
+	if (this.dataTiddler) {
+		var data;
+		// We recall the actual raw data string so
+		// we can see whether it changes later on.
+		this.rawData = getTiddlerString(this.wiki, this.dataTiddler, this.field);
+		if (!this.field || this.field === "text") {
+			data = this.wiki.getTiddlerData(this.dataTiddler);
+		} else {
+			try {
+				data = this.rawData? JSON.parse(this.rawData): {};
+			} catch {
+				data = {};
+			}
+		}
+		for (var entry in data) {
+			var datum = data[entry];
+			// We only accept non-empty values
+			if (datum && typeof datum === "string") {
+				styleObject[entry] = datum;
+			}
+		}
+	}
+	for (var name in this.attributes) {
+		if (name.charAt(0) !== '$' && this.attributes[name]) {
+			styleObject[name] = this.attributes[name];
+		}
+	}
+	return styleObject;
+};
+
+function getTiddlerString(wiki, title, field) {
+	var tiddler = wiki.getTiddler(title);
+	return tiddler && tiddler.getFieldString(field || "text");
+};
+
+Properties.prototype.catchGraphEvent = function(graphEvent, target, variables) {
+	if (graphEvent.objectType === this.type
+	&& this.filterFunc([target.id], this).length > 0) {
+		var actions = this.properties[graphEvent.type];
+		if (actions) {
+			variables.targetTiddler = graphEvent.id;
+			this.invokeActionString(actions, this, graphEvent.event, variables);
+			return true;
+		}
+	}
+	return false;
+};
+
+function propertiesChanged(changedAttributes) {
+	for (var name in changedAttributes) {
+		if (name.charAt(0) !== "$") {
+			return true;
+		}
+	}
+	return false;
+};
+
+exports.properties = Properties;

package/plugins/graph/widgets/subclass/edge.js

@@ -0,0 +1,55 @@
+/*\
+
+Widget for creating edges within graphs.
+
+\*/
+
+"use strict";
+
+var nextId = 1;
+
+exports.baseClass = "graphobject";
+exports.name = "edge";
+// These are object properties that will get added to the variable context
+// when action strings are invoked.
+exports.actionContext = ["id", "fromTiddler", "toTiddler"];
+
+exports.constructor = function(parseTreeNode, options) {
+	this.initialise(parseTreeNode, options);
+};
+
+var EdgeWidget = exports.prototype = {};
+
+EdgeWidget.graphObjectType = "edges";
+
+EdgeWidget.execute = function() {
+	this.id = this.getAttribute("$id");
+	if (!this.id) {
+		// We do this instead of using getAttribute's default arg
+		// so we don't increment unecessarily, and maybe reuse
+		// the same auto-id if this edge refreshes Self. This'll give better
+		// results when updating the graph. It's a CHANGED edge, not a new one.
+		this.counter = this.counter || nextId++;
+		this.id = "$:/edge/" + this.counter;
+	}
+	this.fromTiddler = this.getAttribute("$from", this.getVariable("currentTiddler"));
+	this.toTiddler = this.getAttribute("$to", this.getVariable("toTiddler"));
+	this.makeChildWidgets();
+};
+
+EdgeWidget.setCustomProperties = function(properties) {
+	if (this.fromTiddler) {
+		properties.from = this.fromTiddler;
+	}
+	if (this.toTiddler) {
+		properties.to = this.toTiddler;
+	}
+};
+
+EdgeWidget.curate = function(objects) {
+	// Edges are not legal if there aren't corresponding nodes for its
+	// to and from.
+	return !objects.nodes
+	|| !objects.nodes[this.fromTiddler]
+	|| !objects.nodes[this.toTiddler];
+};

package/plugins/graph/widgets/subclass/edit-color.js

@@ -0,0 +1,52 @@
+/*\
+
+Specialized form of <$edit-text/> which handles displaying palette colors,
+if that's what its underlying value specifies.
+
+\*/
+
+exports.baseClass = "edit-text";
+exports.name = "edit-color";
+
+var ColorType = require("../../propertytypes/color.js");
+
+exports.constructor = function(parseTreeNode, options) {
+	this.initialise(parseTreeNode, options);
+};
+
+var EditWidget = exports.prototype = {};
+
+/*
+We expand on getEditInfo to evaluate any potential palette colors and adust
+the info accordingly.
+*/
+EditWidget.getEditInfo = function() {
+	var info = Object.getPrototypeOf(Object.getPrototypeOf(this)).getEditInfo.call(this);
+	this._rawColor = info.value;
+	if (info.value) {
+		info.value = ColorType.toProperty(null, info.value, {widget: this}) || info.value;
+	}
+	return info;
+};
+
+/*
+We hard-code this widget to be a color input.
+*/
+EditWidget.execute = function() {
+	Object.getPrototypeOf(Object.getPrototypeOf(this)).execute.call(this);
+	this.editType = "color";
+	this.editTag = "input";
+};
+
+/*
+We elaborate refresh to also check if the palette has changed.
+*/
+EditWidget.refresh = function(changedTiddlers) {
+	if (Object.getPrototypeOf(Object.getPrototypeOf(this)).refresh.call(this, changedTiddlers)) {
+		return true;
+	}
+	if (ColorType.refresh(null, this._rawColor, changedTiddlers, this)) {
+		var editInfo = this.getEditInfo();
+		this.updateEditor(editInfo.value, editInfo.type);
+	}
+};