@zakkzhang/tw5-graph 1.6.4

package/plugins/graph/widgets/graphobject.js

@@ -0,0 +1,120 @@
+/*\
+
+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();
+
+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);
+	this.properties = this.refreshProperties();
+	// We're new, so we're changed. Announce ourselves when asked.
+	this.changed = true;
+};
+
+ObjectWidget.prototype.refresh = function(changedTiddlers) {
+	var changedAttributes = this.computeAttributes();
+	// Did our parents experience a change?
+	var possibleChanges = this.computeParents();
+	// Did our own properties change?
+	for (var attribute in changedAttributes) {
+		possibleChanges = true;
+	}
+	// No properties have overtly changed, but maybe they changed covertly...
+	if (!possibleChanges && utils.refreshProperties(this.properties, this, this.graphObjectType, changedTiddlers)) {
+		possibleChanges = true;
+		// We short-circuit this because we have a property that said it's for
+		// sure different.
+		this.changed = true;
+	}
+	if (possibleChanges) {
+		this.execute();
+		this.properties = this.refreshProperties();
+		this.changed = true;
+	}
+	return this.refreshChildren(changedTiddlers) || this.changed;
+};
+
+ObjectWidget.prototype.allowActionPropagation = function() {
+	return false;
+};
+
+ObjectWidget.prototype.refreshProperties = function() {
+	var newProperties = Object.create(null);
+	this.setCustomProperties(newProperties);
+	for (var key in this.attributes) {
+		if (key.charAt(0) !== "$") {
+			var value = this.attributes[key];
+			if (value) {
+				newProperties[key] = this.attributes[key];
+			}
+		}
+	}
+	for (var i = 0; i < this.applicableParents.length; i++) {
+		var widget = this.applicableParents[i];
+		for (var property in widget.properties) {
+			if (!Object.hasOwnProperty.call(newProperties, property)) {
+				newProperties[property] = widget.properties[property];
+			}
+		}
+	}
+	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,131 @@
+/*\
+
+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)
+	|| utils.refreshProperties(this.properties, this, this.type, changedTiddlers)
+	|| 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,47 @@
+/*\
+
+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;
+	}
+};