Colour handling improvements

core/language/en-GB/ControlPanel.multids

@@ -57,6 +57,7 @@ LayoutSwitcher/Caption: Layout
 LoadedModules/Caption: Loaded Modules
 LoadedModules/Hint: These are the currently loaded tiddler modules linked to their source tiddlers. Any italicised modules lack a source tiddler, typically because they were setup during the boot process.
 Palette/Caption: Palette
+Palette/CustomEditor/Prompt: Custom editor for current palette:
 Palette/Editor/Clone/Caption: clone
 Palette/Editor/Clone/Prompt: It is recommended that you clone this shadow palette before editing it
 Palette/Editor/Delete/Hint: delete this entry from the current palette

core/modules/background-actions.js

@@ -0,0 +1,129 @@
+/*\
+title: $:/core/modules/background-actions.js
+type: application/javascript
+module-type: global
+
+Class to dispatch actions when filters change
+
+\*/
+(function(){
+
+/*jslint node: true, browser: true */
+/*global $tw: false */
+"use strict";
+
+function BackgroundActionDispatcher(filterTracker,wiki) {
+	var self = this;
+	this.filterTracker = filterTracker;
+	this.wiki = wiki;
+	this.nextTrackedFilterId = 1;
+	this.trackedFilters = Object.create(null); // Hashmap by id
+	// Track the filter for the background actions
+	this.filterTracker.track({
+		filterString: "[all[tiddlers+shadows]tag[$:/tags/BackgroundAction]!is[draft]]",
+		fnEnter: function fnEnter(title) {
+			return self.trackFilter(title);
+		},
+		fnLeave: function fnLeave(title,enterValue) {
+			self.untrackFilter(enterValue);
+		},
+		fnChange: function fnChange(title,enterValue) {
+			self.untrackFilter(enterValue);
+			return self.trackFilter(title);
+		},
+		fnProcess: function fnProcess(changes) {
+			self.process(changes);
+		}
+	});
+}
+
+BackgroundActionDispatcher.prototype.trackFilter = function(title) {
+	var tiddler = this.wiki.getTiddler(title),
+		id = this.nextTrackedFilterId++,
+		tracker = new BackgroundActionTracker({
+			wiki: this.wiki,
+			title: title,
+			trackFilter: tiddler.fields["track-filter"],
+			actions: tiddler.fields.text
+		});
+	this.trackedFilters[id] = tracker;
+	return id;
+};
+
+BackgroundActionDispatcher.prototype.untrackFilter = function(enterValue) {
+	var tracker = this.trackedFilters[enterValue];
+	if(tracker) {
+		tracker.destroy();
+	}
+	delete this.trackedFilters[enterValue];
+};
+
+BackgroundActionDispatcher.prototype.process = function(changes) {
+	for(var id in this.trackedFilters) {
+		this.trackedFilters[id].process(changes);
+	}
+};
+
+/*
+Represents an individual tracked filter. Options include:
+wiki: wiki to use
+title: title of the tiddler being tracked
+trackFilter: filter string to track changes
+actions: actions to be executed when the filter changes
+*/
+function BackgroundActionTracker(options) {
+	var self = this;
+	this.wiki = options.wiki;
+	this.title = options.title;
+	this.trackFilter = options.trackFilter;
+	this.actions = options.actions
+	this.filterTracker = new $tw.FilterTracker(this.wiki);
+	this.hasChanged = false;
+	this.trackerID = this.filterTracker.track({
+		filterString: this.trackFilter,
+		fnEnter: function(title) {
+			self.hasChanged = true;
+		},
+		fnLeave: function(title,enterValue) {
+			self.hasChanged = true;
+		},
+		fnProcess: function(changes) {
+			if(self.hasChanged) {
+				self.hasChanged = false;
+				console.log("Processing background action",self.title);
+				var tiddler = self.wiki.getTiddler(self.title),
+					doActions = true;
+				if(tiddler && tiddler.fields.platforms) {
+					doActions = false;
+					var platforms = $tw.utils.parseStringArray(tiddler.fields.platforms);
+					if(($tw.browser && platforms.indexOf("browser") !== -1) || ($tw.node && platforms.indexOf("node") !== -1)) {
+						doActions = true;
+					}
+				}
+				if(doActions) {
+					self.wiki.invokeActionString(
+						self.actions,
+						null,
+						{
+							currentTiddler: self.title
+						},{
+							parentWidget: $tw.rootWidget
+						}
+					);
+				}
+			}
+		}
+	});
+}
+
+BackgroundActionTracker.prototype.process = function(changes) {
+	this.filterTracker.handleChangeEvent(changes);
+};
+
+BackgroundActionTracker.prototype.destroy = function() {
+	this.filterTracker.untrack(this.trackerID);
+};
+
+exports.BackgroundActionDispatcher = BackgroundActionDispatcher;
+
+})();

core/modules/editor/engines/simple.js

@@ -31,7 +31,12 @@ function SimpleEngine(options) {
 	if(this.widget.editTag === "textarea") {
 		this.domNode.appendChild(this.widget.document.createTextNode(this.value));
 	} else {
-		this.domNode.value = this.value;
+		if(this.widget.editType === "color") {
+			// The <input type="color"> element requires a six digit hex value
+			this.domNode.value = $tw.utils.convertCSSColorToRGBString(this.value);
+		} else {
+			this.domNode.value = this.value;
+		}
 	}
 	// Set the attributes
 	if(this.widget.editType && this.widget.editTag !== "textarea") {
@@ -86,6 +91,9 @@ Update the DomNode with the new text
 */
 SimpleEngine.prototype.updateDomNodeText = function(text) {
 	try {
+		if(this.widget.editType === "color") {
+			text = $tw.utils.convertRGBStringToCSSColor(text);
+		}
 		this.domNode.value = text;
 	} catch(e) {
 		// Ignore

core/modules/editor/factory.js

@@ -220,12 +220,10 @@ function editTextWidgetFactory(toolbarEngine,nonToolbarEngine) {
 	EditTextWidget.prototype.refresh = function(changedTiddlers) {
 		var changedAttributes = this.computeAttributes();
 		// Completely rerender if any of our attributes have changed
-		if(changedAttributes.tiddler || changedAttributes.field || changedAttributes.index || changedAttributes["default"] || changedAttributes["class"] || changedAttributes.placeholder || changedAttributes.size || changedAttributes.autoHeight || changedAttributes.minHeight || changedAttributes.focusPopup ||  changedAttributes.rows || changedAttributes.tabindex || changedAttributes.cancelPopups || changedAttributes.inputActions || changedAttributes.refreshTitle || changedAttributes.autocomplete || changedTiddlers[HEIGHT_MODE_TITLE] || changedTiddlers[ENABLE_TOOLBAR_TITLE] || changedTiddlers["$:/palette"] || changedAttributes.disabled || changedAttributes.fileDrop) {
+		if(changedAttributes.tiddler || changedAttributes.field || changedAttributes.index || changedAttributes["class"] || changedAttributes.placeholder || changedAttributes.size || changedAttributes.autoHeight || changedAttributes.minHeight || changedAttributes.focusPopup ||  changedAttributes.rows || changedAttributes.tabindex || changedAttributes.cancelPopups || changedAttributes.inputActions || changedAttributes.refreshTitle || changedAttributes.autocomplete || changedTiddlers[HEIGHT_MODE_TITLE] || changedTiddlers[ENABLE_TOOLBAR_TITLE] || changedTiddlers["$:/palette"] || changedAttributes.disabled || changedAttributes.fileDrop) {
 			this.refreshSelf();
 			return true;
-		} else if (changedTiddlers[this.editRefreshTitle]) {
-			this.engine.updateDomNodeText(this.getEditInfo().value);
-		} else if(changedTiddlers[this.editTitle]) {
+		} else if (changedAttributes["default"] || changedTiddlers[this.editRefreshTitle] || changedTiddlers[this.editTitle]) {
 			var editInfo = this.getEditInfo();
 			this.updateEditor(editInfo.value,editInfo.type);
 		}

core/modules/filter-tracker.js

@@ -0,0 +1,108 @@
+/*\
+title: $:/core/modules/filter-tracker.js
+type: application/javascript
+module-type: global
+
+Class to track the results of a filter string
+
+\*/
+(function(){
+
+/*jslint node: true, browser: true */
+/*global $tw: false */
+"use strict";
+
+function FilterTracker(wiki) {
+	this.wiki = wiki;
+	this.trackers = [];
+	this.nextTrackerId = 1;
+}
+
+FilterTracker.prototype.handleChangeEvent = function(changes) {
+	this.processTrackers();
+	this.processChanges(changes);
+};
+
+/*
+Add a tracker to the filter tracker. Returns null if any of the parameters are invalid, or a tracker id if the tracker was added successfully. Options include:
+filterString: the filter string to track
+fnEnter: function to call when a title enters the filter results. Called even if the tiddler does not actually exist. Called as (title), and should return a truthy value that is stored in the tracker as the "enterValue"
+fnLeave: function to call when a title leaves the filter results. Called as (title,enterValue)
+fnChange: function to call when a tiddler changes in the filter results. Only called for filter results that identify a tiddler or shadow tiddler. Called as (title,enterValue), and may optionally return a replacement enterValue
+fnProcess: function to call each time the tracker is processed, after any enter, leave or change functions are called. Called as (changes)
+*/
+FilterTracker.prototype.track = function(options) {
+	// Add the tracker details
+	var tracker = {
+		id: this.nextTrackerId++,
+		filterString: options.filterString,
+		fnEnter: options.fnEnter,
+		fnLeave: options.fnLeave,
+		fnChange: options.fnChange,
+		fnProcess: options.fnProcess,
+		previousResults: [], // Results from the previous time the tracker was processed
+		resultValues: {} // Map by title to the value returned by fnEnter
+	};
+	this.trackers.push(tracker);
+	// Process the tracker
+	this.processTracker(this.trackers.length - 1);
+	return tracker.id;
+};
+
+FilterTracker.prototype.untrack = function(id) {
+	for(var t=0; t<this.trackers.length; t++) {
+		if(this.trackers[t].id === id) {
+			this.trackers.splice(t,1);
+			break;
+		}
+	}
+};
+
+FilterTracker.prototype.processTrackers = function() {
+	for(var t=0; t<this.trackers.length; t++) {
+		this.processTracker(t);
+	}
+};
+
+FilterTracker.prototype.processTracker = function(index) {
+	var tracker = this.trackers[index];
+	var results = [];
+	// Evaluate the filter and remove duplicate results
+	$tw.utils.each(this.wiki.filterTiddlers(tracker.filterString),function(title) {
+		$tw.utils.pushTop(results,title);
+	});
+	// Process the newly entered results
+	$tw.utils.each(results,function(title) {
+		if(tracker.previousResults.indexOf(title) === -1 && !tracker.resultValues[title] && tracker.fnEnter) {
+			tracker.resultValues[title] = tracker.fnEnter(title) || true;
+		}
+	});
+	// Process the results that have just left
+	$tw.utils.each(tracker.previousResults,function(title) {
+		if(results.indexOf(title) === -1 && tracker.resultValues[title] && tracker.fnLeave) {
+			tracker.fnLeave(title,tracker.resultValues[title]);
+			delete tracker.resultValues[title];
+		}
+	});
+	// Update the previous results
+	tracker.previousResults = results;
+};
+
+FilterTracker.prototype.processChanges = function(changes) {
+	for(var t=0; t<this.trackers.length; t++) {
+		var tracker = this.trackers[t];
+		$tw.utils.each(changes,function(change,title) {
+			if(title && tracker.previousResults.indexOf(title) !== -1 && tracker.fnChange) {
+				// Call the change function and if it doesn't return a value then keep the old value
+				tracker.resultValues[title] = tracker.fnChange(title,tracker.resultValues[title]) || tracker.resultValues[title];
+			}
+		});
+		if(tracker.fnProcess) {
+			tracker.fnProcess(changes);
+		}
+	}
+};
+
+exports.FilterTracker = FilterTracker;
+
+})();

core/modules/filters/changecount.js

@@ -0,0 +1,26 @@
+/*\
+title: $:/core/modules/filters/changecount.js
+type: application/javascript
+module-type: filteroperator
+
+Filter operator for retrieving the changecount for each title in the list.
+
+\*/
+(function(){
+
+/*jslint node: true, browser: true */
+/*global $tw: false */
+"use strict";
+
+/*
+Export our filter function
+*/
+exports.changecount = function(source,operator,options) {
+	var results = [];
+	source(function(tiddler,title) {
+		results.push(options.wiki.getChangeCount(title) + "");
+	});
+	return results;
+};
+
+})();