concrete 0.2.0

data/concrete/element_extension.js

@@ -0,0 +1,68 @@
+// Concrete Model Editor
+//
+// Copyright (c) 2010 Martin Thiede
+//
+// Concrete is freely distributable under the terms of an MIT-style license.
+
+Element.addMethods({
+	left: function(e) {
+		return e.cumulativeOffset().left;
+	},
+	right: function(e) {
+		return e.cumulativeOffset().left + Element.getWidth(e);
+	},
+	top: function(e) {
+		return e.cumulativeOffset().top;
+	},
+	bottom: function(e) {
+		return e.cumulativeOffset().top + Element.getHeight(e);
+	},
+	matchesClasses: function(e, classes) {
+		for (var i=0; i<classes.length; i++) {
+			if (e.hasClassName(classes[i])) return true;
+		}
+		return false;
+	},
+	// this method is necessary because Prototype's up() doesn't support searching for multiple classes
+	// optionally a single class may be specified, in this case this is a speed improvement over up()
+	findAncestor: function(e, classes) {
+		var parent = e.parentNode;
+		if (classes instanceof Array) {
+			while (!parent.matchesClasses(classes)) {
+				parent = parent.parentNode;
+				if (!parent || parent.nodeType != 1) return;
+			}
+		}
+		else {
+			while (!parent.hasClassName(classes)) {
+				parent = parent.parentNode;
+				if (!parent || parent.nodeType != 1) return;
+			}			
+		}
+		return parent;
+	},
+	findAncestorOrSelf: function(e, classes) {
+		if ( e.matchesClasses(classes) )
+			return e;
+		else
+			return e.findAncestor(classes);
+	},
+	// collects the first elements on each descendant path which match the searchClasses
+	// stops searching a path when it hits an element matching the stopClasses
+	findFirstDescendants: function(e, searchClasses, stopClasses) {
+		return e.childElements().collect(function(c) {
+			if (c.matchesClasses(searchClasses)) {
+				return c;
+			}
+			else if (c.matchesClasses(stopClasses)) {
+				return [];
+			}
+			else {
+				return c.findFirstDescendants(searchClasses, stopClasses);
+			}
+		}, this).flatten();
+	},
+	allChildren: function(e) {
+    return $A(e.getElementsByTagName("*"));
+	}
+})

data/concrete/external_identifier_provider.js

@@ -0,0 +1,112 @@
+// Concrete Model Editor
+//
+// Copyright (c) 2010 Martin Thiede
+//
+// Concrete is freely distributable under the terms of an MIT-style license.
+
+// Interface ExternalIdentifierProvider
+//
+//  getElementInfo: function(ident, options) {}
+//    returns the element info if +ident+ is the identifier of an element, false otherwise
+//    the element info is an object with properties +type+ and +module+
+//    if option +ignoreModule+ is specified, elements from that module will be ignored
+//
+//  getIdentifiers: function(types) {}
+//    returns the identifiers of all elements of classes given in +types+ 
+
+// assumes an index consisting of modules, each with the following structure: 
+//  [ { name: <module name>, elements: [
+//      { _class: <class name>, name: <element name>, elements: [
+//        { _class: <class name>, name: <element name>, ...
+//
+// optionally the property "elements" may hold a single element instead of an Array
+//
+Concrete.IndexBasedExternalIdentifierProvider = Class.create({
+
+  initialize: function(index, metamodelProvider) {
+    this._index = index;
+    this._metamodelProvider = metamodelProvider;
+    this._separator = "/";
+  },
+
+  getElementInfo: function(ident, options) {
+    if (!Object.isString(ident)) return false;
+    for (var i=0; i<this._index.size(); i++) {
+      var m = this._index[i];
+      if (!options || !options.ignoreModule || options.ignoreModule != m.name) {
+        var parts = ident.split(this._separator);
+        var type = this._getType(m, parts);
+        if (type) return { type: type, module: m.name };
+      }
+    };
+    return false;
+  },
+
+  getIdentifiers: function(type) {
+    var typenames = type.allSubTypes().concat(type).collect(function(t){return t.name});
+    var result = [];
+    this._index.each(function(m) {
+      result = result.concat(this._getIdentifiers(m, typenames, ""));
+    }, this);
+    return result;
+  },
+
+  getAllElementInfo: function() {
+    var result = [];
+    this._index.each(function(m) {
+      result = result.concat(this._getAllElementInfo(m, "", m));
+    }, this);
+    return result;
+  },
+
+  // private
+
+  _getType: function(cont, parts) {
+    var local = parts.shift();
+    while (local == "" && parts.size() > 0) { local = parts.shift() }  
+    if (local == "") return false;
+    var elements = cont.elements
+    if (!(elements instanceof Array)) elements = [elements].compact();
+    var e = elements.find(function(e) { return e.name == local });
+    if (e) {
+      if (parts.size() > 0) {
+        return this._getType(e, parts);
+      }
+      else {
+        return this._metamodelProvider.metaclassesByName[e._class];
+      }
+    }
+    else {
+      return false; 
+    }
+  },
+
+  _getIdentifiers: function(cont, typenames, path) {
+    var result = [];
+    var elements = cont.elements
+    if (!(elements instanceof Array)) elements = [elements].compact();
+    elements.each(function(e) {
+      var epath = path + this._separator + e.name;
+      if (typenames.include(e._class)) {
+        result.push(epath);
+      }
+      result = result.concat(this._getIdentifiers(e, typenames, epath));
+    }, this);
+    return result; 
+  },
+
+  _getAllElementInfo: function(cont, path, module) {
+    var result = [];
+    var elements = cont.elements
+    if (!(elements instanceof Array)) elements = [elements].compact();
+    elements.each(function(e) {
+      var epath = path + this._separator + e.name;
+      result.push({identifier: epath, type: e._class, module: module.name});
+      result = result.concat(this._getAllElementInfo(e, epath, module));
+    }, this);
+    return result; 
+  }
+
+
+});
+

data/concrete/helper.js

@@ -0,0 +1,63 @@
+// Concrete Model Editor
+//
+// Copyright (c) 2010 Martin Thiede
+//
+// Concrete is freely distributable under the terms of an MIT-style license.
+
+Concrete.Helper = {
+	
+	createDOMNode: function(tag, attrs, inner) {
+		var node = new Element(tag);
+		if (attrs.class) node.className = attrs.class;
+		if (attrs.style) node.writeAttribute("style", attrs.style);
+		node.innerHTML = inner;
+		return node;
+	},
+	
+	// simple pretty printing, objects in an array are indented
+	prettyPrintJSON: function(json) {
+		var lastIndex = 0;
+		var result = "";
+		var indent = "";
+		var objectNestLevel = 0;
+		var dedentLevels = [];
+		var firstObject = true;
+		var firstList = true;
+		var writeLine = function(i) {
+			result = result + json.slice(lastIndex, i);
+			lastIndex = i;
+		}
+		for (var i=0; i < json.length; i++) {
+			if (json[i] == "{" ) {
+				writeLine(i);
+				if (!firstObject) result = result + "\n" + indent;
+				firstObject = false;
+				objectNestLevel++;
+			}
+			else if (json[i] == "}" ) {
+				objectNestLevel--;
+				if (objectNestLevel == dedentLevels.last()) {
+					dedentLevels.pop();
+					indent = indent.slice(2);
+				}
+			}
+			else if (json[i] == "[") {
+				writeLine(i+1);
+				if (!firstList) indent = indent + "  ";
+				firstList = false;
+			}
+			else if (json[i] == "]") {
+				indent = indent.slice(2);
+			}
+			else if (json[i] == ":" && json[i+2] == "{") {
+				writeLine(i+2);
+				indent = indent + "  ";
+				dedentLevels.push(objectNestLevel);
+			}
+		}
+		writeLine(json.length);
+		return result;
+	}	
+	
+};
+

data/concrete/identifier_provider.js

@@ -0,0 +1,168 @@
+// Concrete Model Editor
+//
+// Copyright (c) 2010 Martin Thiede
+//
+// Concrete is freely distributable under the terms of an MIT-style license.
+
+Concrete.AbstractIdentifierProvider = Class.create({
+
+	initialize: function() {
+		this._elementByIdentifier = {};
+	},
+	
+	// returns the identifier for +element+
+	// returns undefined if the element has no identifier
+	getIdentifier: function(element) {
+		return element._identifier;
+	},
+	
+	// returns the element associated with +identifier+
+	// returns undefined if there is no element with this identifier
+	getElement: function(identifier) {
+		return this._elementByIdentifier[identifier];
+	},
+
+	// ModelChangeListener Interface
+	
+	elementAdded: function(element) {
+		throw new Error("Abstract, override in subclass");
+	},
+
+	elementChanged: function(element, feature) {
+		throw new Error("Abstract, override in subclass");
+	},
+
+	elementRemoved: function(element) {
+		throw new Error("Abstract, override in subclass");
+	},
+	
+	rootChanged: function(root) {
+		throw new Error("Abstract, override in subclass");		
+	},
+
+	commitChanges: function() {
+		throw new Error("Abstract, override in subclass");		
+	},
+
+	// ModelChangeListener End
+		
+	// Private
+	
+	_changeIdentifier: function(element, identifier) {
+		var identifierChanged = (identifier != element._identifier);
+		if (identifierChanged) {
+			var lastWithSameId = this._elementByIdentifier[identifier];
+			// old identifier
+			if (element._identifier) {
+				var ebi = this._elementByIdentifier[element._identifier];
+				if (ebi instanceof Array) {
+					var idx = ebi.indexOf(element);
+					if (idx >= 0) delete ebi[idx];
+					ebi = ebi.compact();
+					this._elementByIdentifier[element._identifier] = (ebi.size() > 1) ? ebi : ebi.first();
+				}
+				else {
+					delete this._elementByIdentifier[element._identifier];
+				}
+			}
+			// new identifier
+			if (identifier == undefined) {
+				delete element._identifier;	
+			}
+			else {
+				var ebi = this._elementByIdentifier[identifier];
+				if (ebi instanceof Array) {
+					ebi.push(element);
+				}
+				else if (ebi) {
+					this._elementByIdentifier[identifier] = [ebi, element];
+				}
+				else {
+					this._elementByIdentifier[identifier] = element;					
+				}
+				element._identifier = identifier;
+			}
+		}
+	}			
+});
+
+Concrete.QualifiedNameBasedIdentifierProvider = Class.create(Concrete.AbstractIdentifierProvider, {
+	
+	// Options:
+	// - nameAttribute: name of the attribute which holds an element's (non qualified) name, defaults to "name"
+	// - separator: separator between parts (non qualified names) of qualified name, defaults to "/"
+	// - leadingSeparator: specifies if qualified names should start with a leading separator, defaults to "true"
+	initialize: function($super, options) {
+		$super();
+		this.options = options || {};
+		this.options.nameAttribute = this.options.nameAttribute || "name";
+		this.options.separator = this.options.separator || "/";
+		if (this.options.leadingSeparator == undefined) this.options.leadingSeparator = true;
+	},
+
+	// ModelChangeListener Interface
+
+	elementAdded: function(element) {
+		this._updateElement(element);
+	},
+
+	elementChanged: function(element, feature) {
+		this._updateElement(element);
+	},
+
+	elementRemoved: function(element) {
+		this._removeIdentifiers(element);
+	},
+	
+	rootChanged: function(root) {
+	},
+	
+	commitChanges: function() {
+	},
+
+	// ModelChangeListener End
+		
+	_updateElement: function(element) {
+		var parent = element.ancestors().find(function(a) {return a._identifier; });
+		var qnamePrefix = (parent && parent._identifier) || "";
+		this._updateQNames(element, qnamePrefix);
+	},
+	
+	_updateQNames: function(element, qnamePrefix) {
+		var nameAttribute = element.features.find(function(f) { return f.mmFeature.name == this.options.nameAttribute; }, this);
+		var nameValue = nameAttribute && nameAttribute.slot.childElements().select(function(e) { return !e.hasClassName("ct_empty"); }).first();
+		var name = nameValue && nameValue.value;
+		if (name) {
+			if (qnamePrefix.length > 0 || this.options.leadingSeparator) {
+				var qname = qnamePrefix+this.options.separator+name;
+			}
+			else {
+				var qname = name;
+			}
+			this._changeIdentifier(element, qname);
+		}
+		else {
+			var qname = qnamePrefix;
+			this._changeIdentifier(element, undefined);
+		}				
+		element.features.each(function(f) {
+			if (f.mmFeature.isContainment()) {
+				f.slot.childElements().each(function(e) {
+					this._updateQNames(e, qname);
+				}, this);
+			}
+		}, this);
+	},
+	
+	_removeIdentifiers: function(element) {
+		this._changeIdentifier(element, undefined)
+		element.features.each(function(f) {
+			if (f.mmFeature.isContainment()) {
+				f.slot.childElements().each(function(e) {
+					this._removeIdentifiers(e);
+				}, this);
+			}
+		}, this);
+	}			
+});
+	

data/concrete/inline_editor.js

@@ -0,0 +1,55 @@
+// Concrete Model Editor
+//
+// Copyright (c) 2010 Martin Thiede
+//
+// Concrete is freely distributable under the terms of an MIT-style license.
+
+Concrete.InlineEditor = Class.create(Concrete.BasicInlineEditor, {
+
+	initialize: function(stateChangeFunc) {
+		this.stateChangeFunc = stateChangeFunc;
+	},
+	
+	edit: function(element, opt) {
+		var init = opt.init || ""
+		var partial = opt.partial || false
+		if (opt.options instanceof Array) {
+			this._options = opt.options
+			this._regexp = undefined		
+		}
+		else if (opt.options instanceof RegExp) {
+			this._options = []
+			this._regexp = opt.options
+		}
+		else {
+			this._options = []
+		}
+		this._successHandler = opt.onSuccess
+		this._failureHandler = opt.onFailure
+		this.isActive = true
+		this.stateChangeFunc(this.isActive);
+		this.show(element, init, partial, this._options)	
+	},
+	
+	finish: function() {
+		if ((this._options.size() == 0 || this._options.include(this.getText())) && (this._regexp == undefined || this._regexp.test(this.getText()))) {
+			this.isActive = false
+			this.stateChangeFunc(this.isActive);
+			this.hide()
+			if (this._successHandler) this._successHandler(this.getText())
+		}
+		else {
+			this.setError()
+		}
+	},
+	
+	cancel: function() {
+		this.isActive = false
+		this.stateChangeFunc(this.isActive);
+		this.hide()
+		if (this._failureHandler) this._failureHandler()
+	}
+		
+})
+
+