@livinglogic/livingapi 0.13.0 → 0.14.0

package/src/livingapi.js

@@ -2,8 +2,8 @@
  * LivingAPI JavaScript Library
  * https://my.living-apps.de/docs/LivingAPI.html
  *
- * Copyright 2017-2019 by LivingLogic AG, Bayreuth/Germany
- * Copyright 2017-2019 by Walter Dörwald
+ * Copyright 2017-2022 by LivingLogic AG, Bayreuth/Germany
+ * Copyright 2017-2022 by Walter Dörwald
  *
  * All Rights Reserved
  *
@@ -34,6 +34,30 @@ export { version };
 import * as ul4 from '@livinglogic/ul4';
 
 
+export function element(name, ...args)
+{
+	let dom_node = document.createElement(name);
+	for (let arg of args)
+	{
+		if (typeof(arg) === "string")
+			dom_node.appendChild(document.createTextNode(arg));
+		let ismap = arg instanceof Map;
+		let isobject = ul4._isobject(arg);
+		if (ismap || isobject)
+		{
+			if (isobject)
+				arg = Object.entries(arg);
+			for (let [name, value] of arg)
+			{
+				if (value !== null)
+					dom_node.setAttribute(name, value);
+			}
+		}
+	}
+	return dom_node;
+}
+
+
 export class Base extends ul4.Proto
 {
 	constructor(id)
@@ -99,9 +123,24 @@ export class Base extends ul4.Proto
 			}
 			return value;
 		}
+		else if (name.startsWith("x_"))
+		{
+			return this.hasOwnProperty(name) ? this[name] : null;
+		}
 		throw new ul4.AttributeError(this, name);
 	}
 
+	[ul4.symbols.setattr](name, value)
+	{
+		if (name.startsWith("x_"))
+		{
+			this[name] = value;
+		}
+		else
+			throw new ul4.AttributeError(this, name);
+	}
+
+
 	[ul4.symbols.repr]()
 	{
 		return "<" + this.constructor.name + ">";
@@ -126,10 +165,19 @@ export class Handler
 };
 
 
-export class Globals extends Base
+class GlobalsType extends ul4.Type
 {
-	static classdoc = "Global information";
+	instancecheck(obj)
+	{
+		return obj instanceof Globals;
+	}
+};
+
+let globalstype = new GlobalsType("la", "Globals", "Global information");
 
+
+export class Globals extends Base
+{
 	constructor(id)
 	{
 		super(id);
@@ -138,16 +186,27 @@ export class Globals extends Base
 		this.platform = null;
 		this.user = null;
 		this.lang = null;
+		this.datasources = null;
 		this.app = null;
 		this.record = null;
+		this.mode = null;
 		this.maxdbactions = null;
 		this.maxtemplateruntime = null;
 		this.flashmessages = null;
+		this.view_template_id = null;
+		this.email_template_id = null;
 		this.handler = new Handler();
+		this._log_stack = [];
+		this._current_geo = null;
+	}
+
+	[ul4.symbols.type]()
+	{
+		return globalstype;
 	}
 
 	// distance between two geo coordinates (see https://de.wikipedia.org/wiki/Orthodrome#Genauere_Formel_zur_Abstandsberechnung_auf_der_Erde)
-	static geodist(geo1, geo2)
+	geo_dist(geo1, geo2)
 	{
 		let sqsin = function sqsin(x) {x = Math.sin(x); return x*x};
 		let sqcos = function sqsos(x) {x = Math.cos(x); return x*x};
@@ -173,15 +232,15 @@ export class Globals extends Base
 		return s;
 	}
 
-	scaledURL(url, width, height, type="fill", enlarge=true, gravity="sm", quality=null, rotate=null, blur=null, sharpen=null, format=null, cache=true)
+	scaled_url(image, width, height, type="fill", enlarge=true, gravity="sm", quality=null, rotate=null, blur=null, sharpen=null, format=null, cache=true)
 	{
 		let filename = null;
 
-		if (url instanceof File)
+		if (image instanceof File)
 		{
-			url = "https://" + this.hostname + url.url;
-			filename = encodeURIComponent(url.filename);
-			if (filename != url.filename)
+			image = "https://" + this.hostname + image.archive_url;
+			filename = encodeURIComponent(image.filename);
+			if (filename != image.filename)
 				filename = null;
 		}
 
@@ -225,24 +284,207 @@ export class Globals extends Base
 		if (filename !== null && filename !== undefined)
 			result += "/fn:" + filename;
 
-		result += "/plain/" + encodeURIComponent(url);
+		result += "/plain/" + encodeURIComponent(image);
 
 		return result;
 	}
 
 	[ul4.symbols.repr]()
 	{
-		return "<Globals version=" + ul4._repr(this.version) + ">";
+		return "<Globals version=" + ul4._repr(this.version) + " mode=" + ul4._repr(this.mode) + ">";
+	}
+
+	current_geo()
+	{
+		return this._current_geo;
+	}
+
+	set_current_geo(position)
+	{
+		this._current_geo = new Geo(position.coords.latitude, position.coords.longitude);
+	}
+
+	_in_form()
+	{
+		return this.mode !== null && this.mode.startsWith("form/");
+	}
+
+	msg_bool(value)
+	{
+		switch (value)
+		{
+			case true:
+				return this.msg_bool_true();
+			case false:
+				return this.msg_bool_false();
+			default:
+				return null;
+		}
+	}
+
+	msg_bool_true(value)
+	{
+		switch (this.lang)
+		{
+			case "de":
+				return "Ja";
+			default:
+				return "Yes";
+		}
+	}
+
+	msg_bool_false(value)
+	{
+		switch (this.lang)
+		{
+			case "de":
+				return "Nein";
+			default:
+				return "No";
+		}
+	}
+
+	msg_no_fields()
+	{
+		switch (this.lang)
+		{
+			case "de":
+				return "(Keine Felder gefunden)";
+			default:
+				return "(No fields found)";
+		}
+	}
+
+	msg_nothing_selected()
+	{
+		switch (this.lang)
+		{
+			case "de":
+				return "(Nichts ausgewählt)";
+			default:
+				return "(Nothing selected)";
+		}
+	}
+
+	_make_log_message(messages)
+	{
+		return messages
+			.map(m => typeof(m) !== "string" ? ul4._repr(m) : m)
+			.join(" ")
+		;
+	}
+
+	begin_logging(header)
+	{
+		this._log_stack.push({header: header, output: false});
+	}
+
+	end_logging()
+	{
+		if (this._log_stack)
+		{
+			if (this._log_stack[this._log_stack.length-1].output && console && console.groupEnd)
+				console.groupEnd();
+			this._log_stack.pop();
+		}
+	}
+
+	group_logging(header, callback)
+	{
+		this.begin_logging(header);
+		try
+		{
+			callback();
+		}
+		finally
+		{
+			this.end_logging();
+		}
+	}
+
+	_start_log_message()
+	{
+		for (let level of this._log_stack)
+		{
+			if (!level.output)
+			{
+				if (console && console.group)
+					console.group(level.header)
+				level.output = true;
+			}
+		}
+	}
+
+	log_debug(...message)
+	{
+		this._start_log_message();
+		if (console && console.debug)
+			console.debug(this._make_log_message(message))
+	}
+
+	log_info(...message)
+	{
+		this._start_log_message();
+		if (console && console.info)
+			console.info(this._make_log_message(message))
+	}
+
+	log_warning(...message)
+	{
+		this._start_log_message();
+		if (console && console.warn)
+			console.warn(this._make_log_message(message))
+	}
+
+	log_error(...message)
+	{
+		this._start_log_message();
+		if (console && console.error)
+			console.error(this._make_log_message(message))
 	}
 };
 
-Globals.prototype._ul4onattrs = ["version", "platform", "user", "maxdbactions", "maxtemplateruntime", "flashmessages", "lang", "datasources", "hostname", "app", "record", "google_api_key", "mode", "view_template_id", "email_template_id", "view_id"];
-Globals.prototype._ul4attrs = new Set(["version", "hostname", "platform", "user", "lang", "app", "record", "maxdbactions", "maxtemplateruntime", "flashmessages", "mode"]);
+Globals.prototype._ul4onattrs = ["version", "platform", "user", "maxdbactions", "maxtemplateruntime", "lang", "datasources", "hostname", "app", "record", "mode", "view_template_id", "email_template_id", "view_id"];
+Globals.prototype._ul4attrs = new Set(["version", "hostname", "platform", "user", "lang", "datasources", "app", "record", "maxdbactions", "maxtemplateruntime", "flashmessages", "mode", "scaled_url", "geo_dist", "current_geo", "log_debug", "log_info", "log_warning", "log_error"]);
+ul4.expose(Globals.prototype.log_debug, ["message", "*"]);
+ul4.expose(Globals.prototype.log_info, ["message", "*"]);
+ul4.expose(Globals.prototype.log_warning, ["message", "*"]);
+ul4.expose(Globals.prototype.log_error, ["message", "*"]);
+ul4.expose(Globals.prototype.geo_dist, ["geo1", "pk", "geo2", "pk"]);
+ul4.expose(Globals.prototype.current_geo, []);
+ul4.expose(Globals.prototype.scaled_url, [
+	"image", "p",
+	"width", "p",
+	"height", "p",
+	"type", "k=", "fill",
+	"enlarge", "k=", true,
+	"gravity", "k=", "sm",
+	"quality", "k=", null,
+	"rotate", "k=", null,
+	"blur", "k=", null,
+	"sharpen", "k=", null,
+	"format", "k=", null,
+	"cache", "k=", true
+]);
+
+
+class FlashMessageType extends ul4.Type
+{
+	instancecheck(obj)
+	{
+		return obj instanceof FlashMessage;
+	}
+};
+
+let flashmessagetype = new FlashMessageType("la", "FlashMessage", "A flash message in a web page");
 
 
 export class FlashMessage extends Base
 {
-	static classdoc = "A flash message in a web page";
+	[ul4.symbols.type]()
+	{
+		return flashmessagetype;
+	}
 
 	[ul4.symbols.repr]()
 	{
@@ -254,9 +496,23 @@ FlashMessage.prototype._ul4onattrs = ["timestamp", "type", "title", "message"];
 FlashMessage.prototype._ul4attrs = new Set(["timestamp", "type", "title", "message"]);
 
 
+class AppType extends ul4.Type
+{
+	instancecheck(obj)
+	{
+		return obj instanceof App;
+	}
+};
+
+let apptype = new AppType("la", "App", "A LivingApps application");
+
+
 export class App extends Base
 {
-	static classdoc = "A LivingApps application";
+	[ul4.symbols.type]()
+	{
+		return apptype;
+	}
 
 	[ul4.symbols.repr]()
 	{
@@ -311,6 +567,24 @@ export class App extends Base
 				throw new ul4.AttributeError(this, name);
 			return this.controls.get(name.substr(2));
 		}
+		else if (name.startsWith("lc_"))
+		{
+			if (this.layout_controls === null || !this.layout_controls.has(name.substr(3)))
+				throw new ul4.AttributeError(this, name);
+			return this.layout_controls.get(name.substr(3));
+		}
+		else if (name.startsWith("p_") && this.params !== null)
+		{
+			if (!this.params.has(name.substr(2)))
+				throw new ul4.AttributeError(this, name);
+			return this.params.get(name.substr(2));
+		}
+		else if (name.startsWith("pv_") && this.params !== null)
+		{
+			if (!this.params.has(name.substr(3)))
+				throw new ul4.AttributeError(this, name);
+			return this.params.get(name.substr(3)).value;
+		}
 		else
 			return super[ul4.symbols.getattr](name);
 	}
@@ -345,18 +619,39 @@ export class App extends Base
 
 		this._active_view = view;
 	}
+
+	get layout_controls()
+	{
+		if (this.active_views === null)
+			return new Map();
+		return this.active_view.layout_controls;
+	}
 };
 
 
 App.prototype._ul4onattrs = ["globals", "name", "description", "lang", "startlink", "iconlarge", "iconsmall", "createdby", "controls", "records", "recordcount", "installation", "categories", "params", "views", "datamanagement_identifier", "basetable", "primarykey", "insertprocedure", "updateprocedure", "deleteprocedure", "templates", "createdat", "updatedat", "updatedby", "superid", "favorite", "_active_view"];
-App.prototype._ul4attrs = new Set(["id", "globals", "name", "description", "lang", "startlink", "iconlarge", "iconsmall", "createdat", "createdby", "updatedat", "updatedby", "controls", "records", "recordcount", "installation", "categories", "params", "views", "datamanagement_identifier", "insert", "favorite", "_active_view"]);
-ul4.expose(App.prototype[ul4.symbols.call], ["**values"], {"needsobject": true});
-ul4.expose(App.prototype.insert, ["**values"], {"needsobject": true});
+App.prototype._ul4attrs = new Set(["id", "globals", "name", "description", "lang", "startlink", "iconlarge", "iconsmall", "createdat", "createdby", "updatedat", "updatedby", "controls", "layout_controls", "records", "recordcount", "installation", "categories", "params", "views", "datamanagement_identifier", "insert", "favorite", "_active_view"]);
+ul4.expose(App.prototype[ul4.symbols.call], ["values", "**"], {"needsobject": true});
+ul4.expose(App.prototype.insert, ["values", "**"], {"needsobject": true});
+
+
+class ViewType extends ul4.Type
+{
+	instancecheck(obj)
+	{
+		return obj instanceof View;
+	}
+};
+
+let viewtype = new ViewType("la", "View", "An input form for a LivingViews application");
 
 
 export class View extends Base
 {
-	static classdoc = "An input form for a LivingApps application";
+	[ul4.symbols.type]()
+	{
+		return viewtype;
+	}
 
 	[ul4.symbols.repr]()
 	{
@@ -364,28 +659,51 @@ export class View extends Base
 	}
 };
 
-View.prototype._ul4onattrs = ["name", "combined_type", "app", "order", "width", "height", "start", "end", "controls", "layout_controls", "lang"];
-View.prototype._ul4attrs = new Set(["id", "name", "combined_type", "app", "order", "width", "height", "start", "end", "controls", "layout_controls", "lang"]);
+View.prototype._ul4onattrs = ["name", "combined_type", "app", "order", "width", "height", "start", "end", "controls", "layout_controls", "lang", "login_required", "result_page", "use_geo"];
+View.prototype._ul4attrs = new Set(["id", "name", "combined_type", "app", "order", "width", "height", "start", "end", "controls", "layout_controls", "lang", "login_required", "result_page", "use_geo"]);
 
 
-export class DataSourceData extends Base
+class DataSourceType extends ul4.Type
 {
-	static classdoc = "The data resulting from a data source configuration";
+	instancecheck(obj)
+	{
+		return obj instanceof DataSource;
+	}
+};
+
+let datasourcetype = new DataSourceType("la", "DataSource", "The data resulting from a data source configuration");
+
+
+export class DataSource extends Base
+{
+	[ul4.symbols.type]()
+	{
+		return datasourcetype;
+	}
 
 	[ul4.symbols.repr]()
 	{
-		return "<DataSource.Data id=" + ul4._repr(this.id) + " identifier=" + ul4._repr(this.identifier) + ">";
+		return "<DataSource id=" + ul4._repr(this.id) + " identifier=" + ul4._repr(this.identifier) + ">";
 	}
 };
 
-DataSourceData.prototype._ul4onattrs = ["identifier", "app", "apps"];
-DataSourceData.prototype._ul4attrs = new Set(["id", "identifier", "app", "apps"]);
+DataSource.prototype._ul4onattrs = ["identifier", "app", "apps"];
+DataSource.prototype._ul4attrs = new Set(["id", "identifier", "app", "apps"]);
 
 
-export class Record extends Base
+class RecordType extends ul4.Type
 {
-	static classdoc = "A record of a LivingApp application";
+	instancecheck(obj)
+	{
+		return obj instanceof Record;
+	}
+};
+
+let recordtype = new RecordType("la", "Record", "A record of a LivingApp application");
 
+
+export class Record extends Base
+{
 	constructor(id, app)
 	{
 		super(id);
@@ -407,6 +725,35 @@ export class Record extends Base
 		this._is_new = true;
 	}
 
+	[ul4.symbols.type]()
+	{
+		return recordtype;
+	}
+
+	as_text(maxlevel=3, controls=null)
+	{
+		if (maxlevel == 0)
+			return "...";
+		let fields = [];
+		for (let [identifier, control] of (controls || this.app.controls))
+		{
+			if (controls !== null || control.priority)
+			{
+				let fieldvalue = this.fields.get(identifier).value_as_text(maxlevel-1);
+				if (fieldvalue !== null)
+					fields.push([control.label, fieldvalue]);
+			}
+		}
+		if (fields.length === 0)
+			return this.globals.msg_no_fields();
+		else if (fields.length === 1)
+			return fields[0][1];
+		let result = [];
+		for (let [label, fieldvalue] of fields)
+			result.push(label + ": " + fieldvalue);
+		return result.join(", ");
+	}
+
 	_make_fields(defaults, values, errors, lookupdata)
 	{
 		let fields = new Map();
@@ -422,7 +769,7 @@ export class Record extends Base
 				else if (values.has(identifier))
 					value = values.get(identifier);
 			}
-			let field = new Field(control, this, value);
+			let field = new control.fieldtype(control, this, value);
 			fields.set(identifier, field);
 			if (errors !== null && errors.has(identifier))
 				field.errors = errors.get(identifier);
@@ -436,6 +783,13 @@ export class Record extends Base
 		this._sparselookupdata = null;
 	}
 
+	_in_form()
+	{
+		let globals = this.app.globals;
+
+		return globals._in_form() && this === globals.record;
+	}
+
 	[ul4.symbols.repr]()
 	{
 		let v = ["<Record id=", ul4._repr(this.id)];
@@ -596,9 +950,9 @@ export class Record extends Base
 		else if (name.startsWith("f_"))
 			return this.fields.get(name.substr(2))
 		else if (name.startsWith("v_"))
-			return this.values.get(name.substr(2))
+			return this.fields.get(name.substr(2)).value
 		else
-			return this[name];
+			return super[ul4.symbols.getattr](name);
 	}
 
 	[ul4.symbols.setattr](name, value)
@@ -608,37 +962,58 @@ export class Record extends Base
 		else if (name.startsWith("v_"))
 			this.fields.get(name.substr(2)).value = value;
 		else
-			throw new ul4.AttributeError(this, name);
+			return super[ul4.symbols.setattr](name, value);
 	}
 };
 
 Record.prototype._ul4onattrs = ["app", "createdat", "createdby", "updatedat", "updatedby", "updatecount", "_sparsevalues", "attachments", "children", "errors", "_sparsefielderrors", "_sparsefieldlookupdata"];
-Record.prototype._ul4attrs = new Set(["id", "app", "createdat", "createdby", "updatedat", "updatedby", "updatecount", "values", "attachments", "children", "errors"]);
+Record.prototype._ul4attrs = new Set(["id", "app", "createdat", "createdby", "updatedat", "updatedby", "updatecount", "values", "fields", "attachments", "children", "errors"]);
 ul4.expose(Record.prototype.is_dirty, []);
 ul4.expose(Record.prototype.has_errors, []);
 ul4.expose(Record.prototype.delete, []);
 ul4.expose(Record.prototype.save, []);
-ul4.expose(Record.prototype.update, ["**values"], {"needsobject": true});
+ul4.expose(Record.prototype.update, ["values", "**"], {"needsobject": true});
 
 
-export class Field extends Base
+class FieldType extends ul4.Type
 {
-	static classdoc = "Holds the value of a field of a record (and related information)";
+	instancecheck(obj)
+	{
+		return obj instanceof Field;
+	}
+};
+
+let fieldtype = new FieldType("la", "Field", "Holds the value of a field of a record (and related information)");
+
 
+export class Field extends Base
+{
 	constructor(control, record, value)
 	{
 		super(null);
 		this.control = control;
 		this.record = record;
 		this._label = null;
-		this._value = value;
-		this._dirty = false;
-		this._lookupdate = null;
+		this._lookupdata = null;
 		this.errors = [];
+		this._value = null;
+		if (!this._in_form())
+			this.value = value;
+		this._dirty = false;
+		this._enabled = true;
+		this._writable = true;
+		this._visible = true;
+	}
+
+	[ul4.symbols.type]()
+	{
+		return fieldtype;
 	}
 
 	get value()
 	{
+		if (this._in_form())
+			return this._get_dom_value();
 		return this._value;
 	}
 
@@ -656,6 +1031,13 @@ export class Field extends Base
 			this._dirty = true;
 		}
 		this.errors = change.errors;
+		if (this._in_form())
+			this._set_dom_value(this._value);
+	}
+
+	value_as_text(maxlevel=3)
+	{
+		return null;
 	}
 
 	_validate(change)
@@ -663,16 +1045,21 @@ export class Field extends Base
 		// Do nothing, i.e. accept the value unchanged and without errors
 	}
 
+	_set_dom_label()
+	{
+		if (this._in_form())
+			this._dom_label.textContent = this.label;
+	}
+
 	get label()
 	{
-		if (this._label !== null)
-			return this._label;
-		return this.control.label;
+		return this._label ?? this.control.label;
 	}
 
 	set label(value)
 	{
 		this._label = value;
+		this._set_dom_label();
 	}
 
 	get globals()
@@ -682,7 +1069,7 @@ export class Field extends Base
 
 	is_empty()
 	{
-		return this._value === null || (ul4._islist(this._value) && this._value.length === 0);
+		return this._value === null;
 	}
 
 	is_dirty()
@@ -723,7 +1110,7 @@ export class Field extends Base
 
 	msg_string_tooshort(value)
 	{
-		return `"${this.label}" is too short. Tou must use at least ${this.control.minlength} characters!`;
+		return `"${this.label}" is too short. You must use at least ${this.control.minlength} characters!`;
 	}
 
 	msg_string_toolong(value)
@@ -751,6 +1138,11 @@ export class Field extends Base
 		return `"${this.label}" doesn't support this date format!`;
 	}
 
+	msg_number_format(value)
+	{
+		return `"${this.label}" doesn't support this number format!`;
+	}
+
 	msg_lookup_wrongitem(value)
 	{
 		return `The option ${ul4._repr(value)} for "${this.label}" doesn't belong to this lookup!`;
@@ -771,70 +1163,360 @@ export class Field extends Base
 		return `The record ${ul4._repr(value)} for "${this.label}" can't be found!`;
 	}
 
-	[ul4.symbols.repr]()
+	/*
+	The following methods are used in the input form.
+
+	I.e. they are expected to be executed inside a browser.
+	*/
+	_in_form()
 	{
-		let s = "<Field identifier=";
-		s += ul4._repr(this.control.identifier)
-		if (this._dirty)
-			s += " is_dirty()=True";
-		if (this.errors.length > 0)
-			s += " has_errors()=True";
-		s += ">"
-		return s;
+		return this.record._in_form();
 	}
-};
 
-Field.prototype._ul4onattrs = ["control", "record", "label", "value", "errors", "enabled", "writable", "visible"];
-Field.prototype._ul4attrs = new Set(["control", "record", "label", "value", "errors", "enabled", "writable", "visible"]);
+	get _sel_root()
+	{
+		return "#livingapps-form ." + this.control._cssclass_root + ".llft-id-" + this.control.identifier;
+	}
 
+	get _sel_label()
+	{
+		return this._sel_root + " label span";
+	}
 
-export class BoolField extends Field
-{
-	static classdoc = "Holds the value of a bool field of a record (and related information)";
+	get _sel_control()
+	{
+		return this._sel_root + " " + this.control._cssclass_control;
+	}
 
-	_validate(change)
+	get _dom_root()
 	{
-		if (change.value === null)
-		{
-			if (this.control.required)
-				change.errors.push(this.msg_field_required(change.value));
-		}
-		else if (typeof(change.value) === "boolean")
-		{
-			if (this.control.required && !change.value)
-				change.errors.push(this.msg_bool_truerequired(change.value));
-		}
-		else
-		{
-			change.errors.push(this.msg_field_wrong_type(change.value));
-			change.value = null;
-		}
+		return document.querySelector(this._sel_root);
 	}
-};
 
+	get _dom_label()
+	{
+		return document.querySelector(this._sel_label);
+	}
 
-export class IntField extends Field
-{
-	static classdoc = "Holds the value of an int field of a record (and related information)";
+	get _dom_control()
+	{
+		return document.querySelector(this._sel_control);
+	}
 
-	_validate(change)
+	get _dom_controls()
 	{
-		if (change.value === null)
-		{
-			if (this.control.required)
+		return document.querySelectorAll(this._sel_control);
+	}
+
+	_get_dom_value()
+	{
+		return this._dom_control.value;
+	}
+
+	_set_dom_value(value)
+	{
+		this._dom_control.value = value;
+	}
+
+	get visible()
+	{
+		return this._visible;
+	}
+
+	set visible(value)
+	{
+		if (this._in_form())
+			this._dom_root.hidden = !value;
+		this._visible = value;
+	}
+
+	get enabled()
+	{
+		if (this._in_form())
+			return !this._dom_root.classList.contains("llft-control-readonly");
+		else
+			return this._enabled;
+	}
+
+	set enabled(value)
+	{
+		if (this._in_form())
+		{
+			let disabled = !value;
+			for (let node of this._dom_controls)
+				node.disabled = disabled;
+			this._dom_root.classList.toggle("llft-control-readonly", disabled);
+		}
+		this._enabled = value;
+	}
+
+	get writable()
+	{
+		return this._writable;
+	}
+
+	set writable(value)
+	{
+		this._writable = value;
+	}
+
+	[ul4.symbols.repr]()
+	{
+		let s = "<" + this.constructor.name + " identifier=";
+		s += ul4._repr(this.control.identifier)
+		if (this._dirty)
+			s += " is_dirty()=True";
+		if (this.errors.length > 0)
+			s += " has_errors()=True";
+		s += ">"
+		return s;
+	}
+
+	[ul4.symbols.setattr](name, value)
+	{
+		if (name === "value")
+			this.value = value;
+		else if (name === "visible")
+			this.visible = ul4._bool(value);
+		else if (name === "enabled")
+			this.enabled = ul4._bool(value);
+		else if (name === "writable")
+			this.writable = ul4._bool(value);
+		else
+			return super[ul4.symbols.getattr](name);
+	}
+};
+
+Field.prototype._ul4onattrs = ["control", "record", "label", "value", "errors", "_visible", "_enabled", "_writable"];
+Field.prototype._ul4attrs = new Set(["control", "record", "label", "value", "errors", "visible", "enabled", "writable"]);
+Field.prototype._inputevent = "input";
+
+
+class BoolFieldType extends FieldType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof BoolField;
+	}
+};
+
+let boolfieldtype = new BoolFieldType("la", "BoolField", "Holds the value of a bool field of a record (and related information)");
+
+
+export class BoolField extends Field
+{
+	[ul4.symbols.type]()
+	{
+		return boolfieldtype;
+	}
+
+	_validate(change)
+	{
+		if (change.value === null)
+		{
+			if (this.control.required)
+				change.errors.push(this.msg_field_required(change.value));
+		}
+		else if (typeof(change.value) === "boolean")
+		{
+			if (this.control.required && !change.value)
+				change.errors.push(this.msg_bool_truerequired(change.value));
+		}
+		else
+		{
+			change.errors.push(this.msg_field_wrong_type(change.value));
+			change.value = null;
+		}
+	}
+
+	_get_dom_value()
+	{
+		return this._dom_control.checked;
+	}
+
+	_set_dom_value(value)
+	{
+		this._dom_control.checked = value;
+	}
+
+	value_as_text(maxlevel=3)
+	{
+		return this.globals.msg_bool(this.value);
+	}
+};
+
+
+class IntFieldType extends FieldType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof IntField;
+	}
+};
+
+let intfieldtype = new IntFieldType("la", "IntField", "Holds the value of an int field of a record (and related information)");
+
+
+export class IntField extends Field
+{
+	[ul4.symbols.type]()
+	{
+		return intfieldtype;
+	}
+
+	_parse(value)
+	{
+		if (/^\s*[-+]?\d+\s*$/.test(value))
+			return parseInt(value);
+		else
+			return null;
+	}
+
+	_validate(change)
+	{
+		if (change.value === null)
+		{
+			if (this.control.required)
 				change.errors.push(this.msg_field_required(change.value));
 		}
-		else if (typeof(change.value) !== "number" || Math.round(change.value) !== change.value)
+		else if (typeof(change.value) === "string")
+		{
+			let value = this._parse(change.value);
+			if (value !== null)
+				change.value = value;
+			else
+				change.errors.push(this.msg_number_format(change.value));
+				// Keep original invalid string
+		}
+		else if (typeof(change.value) === "number")
+		{
+			if (Math.round(change.value) !== change.value)
+				change.errors.push(this.msg_field_wrong_type(change.value));
+				// Keep original floating point number
+		}
+		else
 		{
 			change.errors.push(this.msg_field_wrong_type(change.value));
+			change.value = null;
+		}
+	}
+
+	_get_dom_value()
+	{
+		let value = super._get_dom_value();
+		if (value)
+		{
+			let testvalue = this._parse(value);
+			if (testvalue !== null)
+				value = testvalue;
+		}
+		return value;
+	}
+
+	_set_dom_value(value)
+	{
+		super._set_dom_value(value + "");
+	}
+
+	value_as_text(maxlevel=3)
+	{
+		let value = this.value;
+		return value != null ? value + "" : null;
+	}
+
+	get writable()
+	{
+		return this._writable;
+	}
+
+	set writable(value)
+	{
+		if (this._in_form())
+		{
+			let readonly = !value;
+			for (let node of this._dom_controls)
+				node.readOnly = readonly;
 		}
+		super.writable = value;
+	}
+};
+
+
+class NumberFieldType extends FieldType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof NumberField;
 	}
 };
 
+let numberfieldtype = new NumberFieldType("la", "NumberField", "Holds the value of a number field of a record (and related information)");
+
 
 export class NumberField extends Field
 {
-	static classdoc = "Holds the value of a number field of a record (and related information)";
+	[ul4.symbols.type]()
+	{
+		return numberfieldtype;
+	}
+
+	_parse(value)
+	{
+		if (value === null)
+			return null;
+
+		// Try to ignore thousands separators and return the value as a number
+		let testvalue = value;
+		// Count decimal delimiters
+		let seps = "";
+		let commas = 0;
+		let dots = 0
+		for (let i = 0; i < value.length; ++i)
+		{
+			let c = value[i];
+			if (c == ",")
+			{
+				commas++;
+				seps += c;
+			}
+			else if (c == ".")
+			{
+				dots++;
+				seps += c;
+			}
+		}
+		let convert = null;
+		if (commas == 0)
+		{
+			if (dots <= 1)
+				; // nothing to do
+			else
+				convert = "de";
+		}
+		else if (commas == 1)
+		{
+			if (dots == 1)
+				convert = (seps == ".,") ? "de" : "en";
+			else
+				convert = "de";
+		}
+		else // commas > 1
+		{
+			if (dots <= 1)
+				convert = "en";
+			else
+				return null; // We can't guess what the user meant
+		}
+
+		if (convert === "de")
+			testvalue = testvalue.replace(/\./g, "").replace(/,/g, ".");
+		else if (convert === "en")
+			testvalue = testvalue.replace(/,/g, "");
+		let floatvalue = parseFloat(testvalue);
+		if (isNaN(floatvalue))
+			return value;
+		return floatvalue;
+	}
 
 	_validate(change)
 	{
@@ -844,34 +1526,739 @@ export class NumberField extends Field
 				change.errors.push(this.msg_field_required(change.value));
 			change.value = null;
 		}
-		else if (typeof(change.value) !== "number")
+		else if (typeof(change.value) === "string")
+		{
+			let value = this._parse(change.value);
+			if (value !== null)
+			{
+				value = this._bound_value(value);
+				if (this.control.precision !== null)
+					value = ul4._round(value, this.control.precision);
+				change.value = value;
+			}
+			else
+				change.errors.push(this.msg_number_format(change.value));
+				// Keep original invalid string
+		}
+		else if (typeof(change.value) === "number")
+		{
+			let value = this._bound_value(change.value);
+			if (this.control.precision !== null)
+				value = ul4._round(value, this.control.precision);
+			change.value = value;
+		}
+		else
 		{
 			change.errors.push(this.msg_field_wrong_type(change.value));
+			change.value = null;
+		}
+	}
+
+	_bound_value(value)
+	{
+		if (this.control.minimum !== null)
+		{
+			if (value < this.control.minimum)
+				value = this.control.minimum;
+		}
+		if (this.control.maximum !== null)
+		{
+			if (value > this.control.maximum)
+				value = this.control.maximum;
 		}
+		return value;
+	}
+
+	_get_dom_value()
+	{
+		let value = super._get_dom_value();
+		if (value)
+		{
+			if (typeof(value) == "string")
+			{
+				let testvalue = this._parse(value);
+				if (testvalue !== null)
+					value = testvalue;
+			}
+			if (typeof(value) === "number")
+			{
+				if (this.control.precision !== null)
+					value = ul4._round(value, this.control.precision);
+				value = this._bound_value(value);
+			}
+		}
+		else
+			value = null;
+		return value;
+	}
+
+	_set_dom_value(value)
+	{
+		if (typeof(value) === "number")
+		{
+			value = this._bound_value(value);
+			if (this.control.precision !== null)
+				value = value.toFixed(this.control.precision);
+		}
+		value += "";
+		if (this.globals.lang == "de" && this.control.precision === null)
+			value = value.replace(".", ",");
+		super._set_dom_value(value);
+	}
+
+	value_as_text(maxlevel=3)
+	{
+		let value = this.value;
+		if (value === null)
+			return null;
+		if (this.control.precision !== null)
+			return value.toFixed(this.control.precision);
+		return value.toString();
+	}
+
+	get writable()
+	{
+		return this._writable;
+	}
+
+	set writable(value)
+	{
+		if (this._in_form())
+		{
+			let readonly = !value;
+			for (let node of this._dom_controls)
+				node.readOnly = readonly;
+		}
+		super.writable = value;
+	}
+};
+
+
+class StringFieldType extends FieldType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof StringField;
 	}
 };
 
+let stringfieldtype = new StringFieldType("la", "StringField", "Holds the value of a string field of a record (and related information)");
+
 
 export class StringField extends Field
 {
-	static classdoc = "Holds the value of a string field of a record (and related information)";
+	[ul4.symbols.type]()
+	{
+		return stringfieldtype;
+	}
 
 	_validate(change)
 	{
 		if (change.value === null || change.value === "")
 		{
-			if (this.control.required)
-				change.errors.push(this.msg_field_required(change.value));
-			change.value = null;
+			if (this.control.required)
+				change.errors.push(this.msg_field_required(change.value));
+			change.value = null;
+		}
+		else if (typeof(change.value) === "string")
+		{
+			let minlength = this.control.minlength;
+			let maxlength = this.control.maxlength;
+			if (minlength !== null && change.value.length < minlength)
+				change.errors.push(this.msg_string_tooshort(change.value))
+			if (maxlength !== null && change.value.length > maxlength)
+				change.errors.push(this.msg_string_toolong(change.value))
+		}
+		else
+		{
+			change.errors.push(this.msg_field_wrong_type(change.value));
+			change.value = null;
+		}
+	}
+
+	get writable()
+	{
+		return this._writable;
+	}
+
+	set writable(value)
+	{
+		if (this._in_form())
+		{
+			let readonly = !value;
+			for (let node of this._dom_controls)
+				node.readOnly = readonly;
+		}
+		super.writable = value;
+	}
+
+	value_as_text(maxlevel=3)
+	{
+		return this.value;
+	}
+};
+
+
+class PasswordFieldType extends StringFieldType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof PasswordField;
+	}
+};
+
+let passwordfieldtype = new PasswordFieldType("la", "PasswordField", "Holds the value of a string/password field of a record (and related information)");
+
+
+export class PasswordField extends StringField
+{
+	[ul4.symbols.type]()
+	{
+		return passwordfieldtype;
+	}
+};
+
+
+class EmailFieldType extends StringFieldType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof EmailField;
+	}
+};
+
+let emailfieldtype = new EmailFieldType("la", "EmailField", "Holds the value of a string/email field of a record (and related information)");
+
+
+export class EmailField extends StringField
+{
+	[ul4.symbols.type]()
+	{
+		return emailfieldtype;
+	}
+
+	_validate(change)
+	{
+		if (typeof(change.value) === "string" && change.value.length > 0)
+		{
+			const re = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/i;
+			if (!re.test(change.value))
+				change.errors.push(this.msg_email_format(change.value));
+		}
+		super._validate(change);
+	}
+};
+
+
+class URLFieldType extends StringFieldType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof URLField;
+	}
+};
+
+let urlfieldtype = new URLFieldType("la", "URLField", "Holds the value of a string/url field of a record (and related information)");
+
+
+export class URLField extends StringField
+{
+	[ul4.symbols.type]()
+	{
+		return urlfieldtype;
+	}
+
+	_validate(change)
+	{
+		if (typeof(change.value) === "string" && change.value.length > 0)
+		{
+			let url = null;
+			try
+			{
+				url = new URL(change.value);
+			}
+			catch (exc)
+			{
+				change.errors.push(this.msg_url_format(change.value));
+			}
+			if (url !== null && url.protocol !== "http:" && url.protocol !== "https:")
+			{
+				change.errors.push(this.msg_url_format(change.value));
+			}
+		}
+		super._validate(change);
+	}
+};
+
+
+class TelFieldType extends StringFieldType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof TelField;
+	}
+};
+
+let telfieldtype = new TelFieldType("la", "TelField", "Holds the value of a string/tel field of a record (and related information)");
+
+
+export class TelField extends StringField
+{
+	[ul4.symbols.type]()
+	{
+		return telfieldtype;
+	}
+
+	_validate(change)
+	{
+		if (typeof(change.value) === "string" && change.value.length > 0)
+		{
+			const re = /^\\+?[0-9 /()-]+$/;
+			if (!re.test(change.value))
+				change.errors.push(this.msg_tel_format(change.value));
+		}
+		super._validate(change);
+	}
+};
+
+
+class TextAreaFieldType extends StringFieldType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof TextAreaField;
+	}
+};
+
+let textareafieldtype = new TextAreaFieldType("la", "TextAreaField", "Holds the value of a string/textarea field of a record (and related information)");
+
+
+export class TextAreaField extends StringField
+{
+	[ul4.symbols.type]()
+	{
+		return textareafieldtype;
+	}
+};
+
+
+class HTMLFieldType extends StringFieldType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof HTMLField;
+	}
+};
+
+let htmlfieldtype = new HTMLFieldType("la", "HTMLField", "Holds the value of a string/html field of a record (and related information)");
+
+
+export class HTMLField extends StringField
+{
+	[ul4.symbols.type]()
+	{
+		return htmlfieldtype;
+	}
+};
+
+
+class GeoFieldType extends FieldType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof GeoField;
+	}
+};
+
+let geofieldtype = new GeoFieldType("la", "GeoField", "Holds the value of a geo field of a record (and related information)");
+
+
+export class GeoField extends Field
+{
+	[ul4.symbols.type]()
+	{
+		return geofieldtype;
+	}
+
+	_get_dom_value()
+	{
+		for (let dom_node of this._dom_controls)
+		{
+			if (dom_node.id.endsWith("_geoinfo"))
+			{
+				let value = dom_node.value;
+				if (value)
+				{
+					value = JSON.parse(value);
+					return new Geo(
+						value.geometry.coordinates[0],
+						value.geometry.coordinates[1],
+						value.properties.formatted_address
+					);
+				}
+			}
+		}
+		return null;
+	}
+
+	_set_dom_value(value)
+	{
+		if (value === null)
+		{
+			for (let dom_node of this._dom_controls)
+			{
+				dom_node.value = null;
+			}
+		}
+		else
+		{
+			for (let dom_node of this._dom_controls)
+			{
+				if (dom_node.id.endsWith("_geoinfo"))
+				{
+					let dom_value = {
+						"type": "Feature",
+						"geometry": {
+							"coordinates": [
+								value.lat,
+								value.long
+							]
+						},
+						"properties": {
+							"formatted_address": value.info
+						}
+					};
+					dom_node.value = ul4._asjson(dom_value);
+				}
+				else
+					dom_node.value = value.info;
+			}
+		}
+	}
+
+	value_as_text(maxlevel=3)
+	{
+		let value = this.value;
+		if (this.value === null)
+			return null;
+		// FIXME: Show N/S and W/E? Show arc minutes/seconds?
+		let result = value.lat.toFixed(5) + ", " + value.long.toFixed(5);
+		if (value.info !== null)
+			result += " (" + value.info + ")";
+		return result;
+	}
+
+	_validate(change)
+	{
+		if (change.value === null || change.value === "")
+		{
+			if (this.control.required)
+				change.errors.push(this.msg_field_required(change.value));
+			change.value = null;
+		}
+		else if (!(change.value instanceof Geo))
+		{
+			change.errors.push(this.msg_field_wrong_type(change.value));
+			change.value = null;
+		}
+	}
+};
+GeoField.prototype._inputevent = "llgeo";
+
+
+class FileFieldType extends FieldType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof FileField;
+	}
+};
+
+let filefieldtype = new FileFieldType("la", "FileField", "Holds the value of a file field of a record (and related information)");
+
+
+export class FileField extends Field
+{
+	[ul4.symbols.type]()
+	{
+		return filefieldtype;
+	}
+
+	_validate(change)
+	{
+		if (change.value === null || change.value === "")
+		{
+			if (this.control.required)
+				change.errors.push(this.msg_field_required(change.value));
+			change.value = null;
+		}
+		else if (!(change.value instanceof File))
+		{
+			change.errors.push(this.msg_field_wrong_type(change.value));
+			change.value = null;
+		}
+	}
+
+	_get_dom_value()
+	{
+		// Always return `null``
+		return null;
+	}
+
+	_set_dom_value()
+	{
+		// Do nothing
+	}
+};
+
+
+class FileSignatureFieldType extends FileFieldType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof FileSignatureField;
+	}
+};
+
+let filesignaturefieldtype = new FileSignatureFieldType("la", "FileSignatureField", "Holds the value of a file/signature field of a record (and related information)");
+
+
+export class FileSignatureField extends FileField
+{
+	[ul4.symbols.type]()
+	{
+		return filesignaturefieldtype;
+	}
+
+	_validate(change)
+	{
+		// FIXME: Implement handling of data URLs.
+		super._validate(change);
+	}
+};
+
+
+class DateFieldBaseType extends FieldType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof DateFieldBase;
+	}
+};
+
+let datefieldbasetype = new DateFieldBaseType("la", "DateFieldBase", "Holds the value of a date field of a record (and related information)");
+
+
+export class DateFieldBase extends Field
+{
+	[ul4.symbols.type]()
+	{
+		return datefieldbasetype;
+	}
+
+	value_as_text(maxlevel=3)
+	{
+		let value = this.value;
+		if (value === null)
+			return null;
+		if (typeof(value) === "string")
+			return value;
+		return ul4._format(value, this.control.formatstring())
+	}
+
+	_parse(value, format)
+	{
+		let year = null, month = null, day = null, hour = 0, minute = 0, second = 0, ispm = null;
+
+		function _int(v, len, min, max)
+		{
+			v = v.substring(0, len);
+			if (v.length != len)
+				return null;
+			v = parseInt(v, 10);
+			if (isNaN(v) || v < min || v > max)
+				return null;
+			return v;
+		}
+
+		while (value)
+		{
+			// Are both `value` and `format` not `null`,
+			// i.e. neither `value` nor `format` is exhaused?
+			if (!format)
+				return null;
+			if (format.startsWith("%Y"))
+			{
+				year = _int(value, 4);
+				if (year === null)
+					return null;
+				value = value.substring(4);
+				format = format.substring(2);
+			}
+			else if (format.startsWith("%y"))
+			{
+				year = _int(value, 2);
+				if (year === null)
+					return null;
+				value = value.substring(2);
+				format = format.substring(2);
+			}
+			else if (format.startsWith("%m"))
+			{
+				month = _int(value, 2);
+				if (month === null)
+					return null;
+				value = value.substring(2);
+				format = format.substring(2);
+			}
+			else if (format.startsWith("%d"))
+			{
+				day = _int(value, 2);
+				if (day === null)
+					return null;
+				value = value.substring(2);
+				format = format.substring(2);
+			}
+			else if (format.startsWith("%H"))
+			{
+				hour = _int(value, 2);
+				if (hour === null)
+					return null;
+				value = value.substring(2);
+				format = format.substring(2);
+			}
+			else if (format.startsWith("%I"))
+			{
+				hour = _int(value, 2);
+				if (hour === null)
+					return null;
+				value = value.substring(2);
+				format = format.substring(2);
+			}
+			else if (format.startsWith("%M"))
+			{
+				minute = _int(value, 2);
+				if (minute === null)
+					return null;
+				value = value.substring(2);
+				format = format.substring(2);
+			}
+			else if (format.startsWith("%S"))
+			{
+				second = _int(value, 2);
+				if (second === null)
+					return null;
+				value = value.substring(2);
+				format = format.substring(2);
+			}
+			else if (format.startsWith("%p"))
+			{
+				if (value.toLowerCase().startsWith("pm"))
+					ispm = true;
+				else if (value.toLowerCase().startsWith("am"))
+					ispm = false;
+				else
+					return null;
+				value = value.substring(2);
+				format = format.substring(2);
+			}
+			else if (format.startsWith("%%"))
+			{
+				if (!value.startsWith("%"))
+					return null;
+				value = value.substring(1);
+				format = format.substring(2);
+			}
+			else if (format.startsWith("%z"))
+			{
+				if (!value.startsWith("-") && !value.startsWith("+"))
+					return null;
+				value = value.substring(1);
+				let _tzhour = _int(value, 2);
+				if (_tzhour === null)
+					return null;
+				value = value.substring(2);
+				if (!value.startsWith(":"))
+					return null;
+				value = value.substring(1);
+				let _tzminute = _int(value, 2);
+				if (_tzminute === null)
+					return null;
+				value = value.substring(2);
+				format = format.substring(2);
+			}
+			else
+			{
+				if (!value.startsWith(format.substring(0, 1)))
+					return null;
+				value = value.substring(1);
+				format = format.substring(1);
+			}
+		}
+		// Are both `value` and `format` `null`?
+		// I.e. both `value` and `format` must be exhausted, otherwise ...
+		if (format)
+			// ... `format` has remaining content that the value didn't provide
+			return null;
+
+		// Check existance of values and their range
+		if (year === null)
+			return null;
+		if (month === null || month < 1 || month > 12)
+			return null;
+		if (day === null || day < 1 || day > 31) // FIXME: Use the actuall number of days
+			return null;
+		if (ispm === null)
+		{
+			if (hour < 0 || hour > 23)
+				return null;
+		}
+		else
+		{
+			if (hour < 0 || hour > 11)
+				return null;
+			if (ispm)
+				hour += 12;
+		}
+		if (minute < 0 || minute > 59)
+			return null;
+		if (minute < 0 || minute > 59)
+			return null;
+		if (second < 0 || second > 60)
+			return null;
+		return new Date(year, month-1, day, hour, minute, second);
+	}
+
+	_validate(change)
+	{
+		if (change.value === null || change.value === "")
+		{
+			if (this.control.required)
+				change.errors.push(this.msg_field_required(change.value));
+			change.value = null;
+		}
+		else if (change.value instanceof Date)
+		{
+			change.value = this._convert(change.value);
+		}
+		else if (change.value instanceof ul4.Date_)
+		{
+			change.value = this._convert(change.value._date);
 		}
 		else if (typeof(change.value) === "string")
 		{
-			let minlength = this.control.minlength;
-			let maxlength = this.control.maxlength;
-			if (minlength !== null && change.value.length < minlength)
-				change.errors.push(this.msg_string_tooshort(change.value))
-			if (maxlength !== null && change.value.length > maxlength)
-				change.errors.push(this.msg_string_toolong(change.value))
+			let value = null;
+			for (let format of this.control.formatstrings_parse())
+			{
+				value = this._parse(change.value, format);
+				if (value !== null)
+					break;
+			}
+			if (value !== null)
+				change.value = this._convert(value);
+			else
+				change.errors.push(this.msg_date_format(change.value));
+				// Keep original invalid string
 		}
 		else
 		{
@@ -879,234 +2266,275 @@ export class StringField extends Field
 			change.value = null;
 		}
 	}
-};
-
-
-export class EmailField extends StringField
-{
-	static classdoc = "Holds the value of a string/email field of a record (and related information)";
 
-	_validate(change)
+	_get_dom_value()
 	{
-		if (typeof(change.value) === "string" && change.value.length > 0)
+		let value = super._get_dom_value();
+		if (!value)
+			return null;
+
+		for (let format of this.control.formatstrings_parse())
 		{
-			const re = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/i;
-			if (!re.test(change.value))
-				change.errors.push(this.msg_email_format(change.value));
+			let date = this._parse(value, format);
+			if (date !== null)
+				return this._convert(date);
 		}
-		super._validate(change);
+		return null;
+	}
+
+	_set_dom_value(value)
+	{
+		if (value !== null)
+			value = ul4._format(value, this.control.formatstring(), this.globals.lang);
+		super._set_dom_value(value);
 	}
 };
 
 
-export class URLField extends StringField
+class DateFieldType extends DateFieldBaseType
 {
-	static classdoc = "Holds the value of a string/url field of a record (and related information)";
-
-	_validate(change)
+	instancecheck(obj)
 	{
-		if (typeof(change.value) === "string" && change.value.length > 0)
-		{
-			let url = null;
-			try
-			{
-				url = new URL(change.value);
-			}
-			catch (exc)
-			{
-				change.errors.push(this.msg_url_format(change.value));
-			}
-			if (url !== null && url.protocol !== "http:" && url.protocol !== "https:")
-			{
-				change.errors.push(this.msg_url_format(change.value));
-			}
-		}
-		super._validate(change);
+		return obj instanceof DateField;
 	}
 };
 
+let datefieldtype = new DateFieldType("la", "DateField", "Holds the value of a date/date field of a record (and related information)");
 
-export class TelField extends StringField
+
+export class DateField extends DateFieldBase
 {
-	static classdoc = "Holds the value of a string/tel field of a record (and related information)";
+	[ul4.symbols.type]()
+	{
+		return datefieldtype;
+	}
 
-	_validate(change)
+	_convert(date)
 	{
-		if (typeof(change.value) === "string" && change.value.length > 0)
-		{
-			const re = /^\\+?[0-9 /()-]+$/;
-			if (!re.test(change.value))
-				change.errors.push(this.msg_tel_format(change.value));
-		}
-		super._validate(change);
+		return new ul4.Date_(date.getFullYear(), date.getMonth()+1, date.getDate());
 	}
 };
 
 
-export class TextAreaField extends StringField
+class DatetimeMinuteFieldType extends DateFieldBaseType
 {
-	static classdoc = "Holds the value of a string/textarea field of a record (and related information)";
+	instancecheck(obj)
+	{
+		return obj instanceof DatetimeMinuteField;
+	}
 };
 
-
-export class HTMLField extends StringField
-{
-	static classdoc = "Holds the value of a string/html field of a record (and related information)";
-};
+let datetimeminutefieldtype = new DatetimeMinuteFieldType("la", "DatetimeMinuteField", "Holds the value of a date/datetimeminute field of a record (and related information)");
 
 
-export class GeoField extends Field
+export class DatetimeMinuteField extends DateFieldBase
 {
-	static classdoc = "Holds the value of a geo field of a record (and related information)";
+	[ul4.symbols.type]()
+	{
+		return datetimeminutefieldtype;
+	}
 
-	_validate(change)
+	_convert(date)
 	{
-		if (change.value === null || change.value === "")
-		{
-			if (this.control.required)
-				change.errors.push(this.msg_field_required(change.value));
-			change.value = null;
-		}
-		else if (!(change.value instanceof Geo))
-		{
-			change.errors.push(this.msg_field_wrong_type(change.value));
-			change.value = null;
-		}
+		// Get rid of seconds and milliseconds, this modifies the object passed in.
+		date.setSeconds(0);
+		date.setMilliseconds(0);
+		return date;
 	}
 };
 
 
-export class FileField extends Field
+class DatetimeSecondFieldType extends DateFieldBaseType
 {
-	static classdoc = "Holds the value of a file field of a record (and related information)";
-
-	_validate(change)
+	instancecheck(obj)
 	{
-		if (change.value === null || change.value === "")
-		{
-			if (this.control.required)
-				change.errors.push(this.msg_field_required(change.value));
-			change.value = null;
-		}
-		else if (!(change.value instanceof File))
-		{
-			change.errors.push(this.msg_field_wrong_type(change.value));
-			change.value = null;
-		}
+		return obj instanceof DatetimeSecondField;
 	}
 };
 
+let datetimesecondfieldtype = new DatetimeSecondFieldType("la", "DatetimeSecondField", "Holds the value of a date/datetimesecond field of a record (and related information)");
 
-export class FileSignatureField extends FileField
+
+export class DatetimeSecondField extends DateFieldBase
 {
-	static classdoc = "Holds the value of a file/signature field of a record (and related information)";
+	[ul4.symbols.type]()
+	{
+		return datetimesecondfieldtype;
+	}
 
-	_validate(change)
+	_convert(date)
 	{
-		// FIXME: Implement handling of data URLs.
-		super._validate(change);
+		// Get rid of milliseconds, this modifies the object passed in.
+		date.setMilliseconds(0);
+		return date;
 	}
 };
 
+/*
+`ChoiceFieldBase` is used as the base class for all `lookup`, `multiplelookup`,
+`applookup` and `multipleapplookup` fields.
 
-export class DateFieldBase extends Field
+Since the inheritance hierarchy follows the data model *not* which HTML element
+is used for editing, we would have to implement the same DOM interaction logic
+in multiple classes (i.e. we would have to handle a HTML `select` element in
+`LookupSelectField`, `MultipleLookupSelectField`, `AppLookupSelectField`
+and `MultipleAppLookupSelectField`).
+
+To solve this problem, all methods that handle HTML elements are implemented in
+this class. Subclasses then simply call the appropriate method.
+*/
+export class ChoiceFieldBase extends Field
 {
-	static classdoc = "Holds the value of a date field of a record (and related information)";
+	_make_option(selected, value, label)
+	{
+		let option = element(
+			"option",
+			label,
+			{
+				"value": value,
+				"class": value === this.control.nonekey ? "la-none-option" : null,
+				"selected": selected ? "selected" : null,
+			}
+		);
+		return option;
+	}
 
-	_validate(change)
+	_set_dom_lookupdata_select(lookupdata)
 	{
-		if (change.value === null || change.value === "")
+		if (lookupdata === null)
+			lookupdata = this.control.lookup_data;
+		if (ul4._isobject(lookupdata))
+			lookupdata = new Map(Object.entries(lookupdata));
+
+		let none_selected = false;
+		let selected = new Set();
+		for (let dom_option of this._dom_control.querySelectorAll("option:checked"))
 		{
-			if (this.control.required)
-				change.errors.push(this.msg_field_required(change.value));
-			change.value = null;
+			let value = dom_option.getAttribute("value");
+			if (lookupdata.has(value))
+				selected.add(value);
+			else if (value === this.control.nonekey)
+				none_selected = true;
 		}
-		else if (change.value instanceof Date)
+
+		let new_children = [];
+		if (this.control.nonekey !== null)
 		{
-			change.value = this._convert(new Date(change.value.getTime()));
+			new_children.push(
+				this._make_option(
+					none_selected,
+					this.control.nonekey,
+					this.control.nonelabel !== null ? this.control.nonelabel : this.globals.msg_nothing_selected()
+				)
+			);
 		}
-		else if (typeof(change.value) === "string")
+
+		for (let [key, value] of lookupdata)
 		{
-			let value = null;
-			if (change.value.length === 10)
-				value = new Date(change.value + "T00:00:00");
-			else if (change.value.length === 16)
-				value = new Date(change.value + ":00");
-			else if (change.value.length === 19)
-				value = new Date(change.value);
-
-			if (value === null || Number.isNaN(value.getYear()))
+			new_children.push(
+				this._make_option(
+					selected.has(key),
+					key,
+					this._make_label(value)
+				)
+			);
+		}
+		this._dom_control.replaceChildren(...new_children);
+	}
+
+	_set_dom_lookupdata_input(lookupdata)
+	{
+		if (lookupdata === null)
+			lookupdata = this.control.lookupdata;
+		else if (ul4._isobject(lookupdata))
+			lookupdata = new Map(Object.entries(lookupdata));
+
+		let none_selected = false;
+		let selected = new Set();
+		for (let dom_input of this._dom_controls)
+		{
+			let value = dom_input.getAttribute("value");
+			if (dom_input.checked)
 			{
-				change.errors.push(this.msg_date_format(change.value));
-				// Keep original invalid string
+				if (lookupdata.has(value))
+					selected.add(value);
+				else if (value === this.control.nonekey)
+					none_selected = true;
+
+			}
+		}
+
+		let dom_none_input = this._dom_root.querySelector("input[value=" + this.control.nonekey + "]");
+		if (dom_none_input !== null)
+			dom_none_input.checked = none_selected;
+
+		for (let [key, item] of this.control.lookupdata)
+		{
+			let dom_input = this._dom_root.querySelector("input[value=" + key + "]");
+			let dom_label = this._dom_root.querySelector("label[for=" + dom_input.id + "]")
+
+			if (lookupdata.has(key))
+			{
+				dom_input.style.display = "inline";
+				dom_label.style.display = "inline";
+				dom_label.innerText = this._make_label(lookupdata.get(key));
 			}
 			else
 			{
-				change.value = this._convert(value);
+				dom_input.style.display = "none";
+				dom_label.style.display = "none";
+				dom_label.checked = false;
 			}
 		}
-		else
-		{
-			change.errors.push(this.msg_field_wrong_type(change.value));
-			change.value = null;
-		}
 	}
 };
 
 
-export class DateField extends DateFieldBase
+class LookupFieldBaseType extends FieldType
 {
-	static classdoc = "Holds the value of a date/date field of a record (and related information)";
-
-	_convert(date)
+	instancecheck(obj)
 	{
-		return new ul4.Date_(date.getFullYear(), date.getMonth()+1, date.getDate());
+		return obj instanceof LookupFieldBase;
 	}
 };
 
-
-export class DatetimeMinuteField extends DateFieldBase
-{
-	static classdoc = "Holds the value of a date/datetimeminute field of a record (and related information)";
-
-	_convert(date)
-	{
-		// Get rid of seconds and milliseconds
-		date.setSeconds(0);
-		date.setMilliseconds(0);
-		return date;
-	}
-};
+let lookupfieldbasetype = new LookupFieldBaseType("la", "LookupFieldBase", "Base type of LookupField and MultipleLookupField");
 
 
-export class DatetimeSecondField extends DateFieldBase
+export class LookupFieldBase extends ChoiceFieldBase
 {
-	static classdoc = "Holds the value of a date/datetimesecond field of a record (and related information)";
-
-	_convert(date)
+	[ul4.symbols.type]()
 	{
-		// Get rid of milliseconds
-		date.setMilliseconds(0);
-		return date;
+		return lookupfieldbasetype;
 	}
-};
-
-
-export class LookupFieldBase extends Field
-{
-	static classdoc = "Base type of LookupField and MultipleLookupField";
 
 	get lookupdata()
 	{
-		if (this._lookupdate !== null)
-			return this._lookupdate;
+		if (this._lookupdata !== null)
+			return this._lookupdata;
 		else
 			return this.control.lookupdata;
 	}
 
 	set lookupdata(value)
 	{
-		this._lookupdate = value;
+		if (this._in_form())
+			this._set_dom_lookupdata(value);
+		this._lookupdata = value;
+	}
+
+	_set_dom_lookupdata(lookupdata)
+	{
+	}
+
+	_make_label(value)
+	{
+		if (typeof(value) === "string")
+			return value;
+		else if (value instanceof LookupItem)
+			return value.label;
+		else
+			return ul4._str(value);
 	}
 
 	_find_lookupitem(change)
@@ -1114,12 +2542,12 @@ export class LookupFieldBase extends Field
 		let v = change.value;
 		if (typeof(v) === "string")
 		{
-			// If `lookupdata`} is `null`, this is probably an interface,
+			// If `lookupdata` is `null`, this probably an interface,
 			// so we can't validate anything (note that interfaces will however go
 			// away in the future)
 			if (this.lookupdata === null)
 				return;
-			let lookupitem = this.lookupdata.get(v);
+			let lookupitem = this.control.lookupdata.get(v);
 			if (lookupitem === undefined)
 			{
 				// If the lookup control is auto expandable,
@@ -1166,30 +2594,199 @@ export class LookupFieldBase extends Field
 };
 
 
-export class LookupField extends LookupFieldBase
+class LookupFieldType extends LookupFieldBaseType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof LookupField;
+	}
+};
+
+let lookupfieldtype = new LookupFieldType("la", "LookupField", "Holds the value of a lookup field of a record (and related information)");
+
+
+export class LookupField extends LookupFieldBase
+{
+	[ul4.symbols.type]()
+	{
+		return lookupfieldtype;
+	}
+
+	value_as_text(maxlevel=3)
+	{
+		let value = this.value;
+		if (value === null)
+			return null;
+		return value.label;
+	}
+
+	_validate(change)
+	{
+		let v = change.value;
+		if (v === null || v === "" || this.control.nonekey === v)
+		{
+			if (this.control.required)
+				change.errors.push(this.msg_field_required(v));
+			change.value = null;
+		}
+		else
+		{
+			this._find_lookupitem(change);
+		}
+	}
+};
+
+
+class LookupRadioFieldType extends LookupFieldType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof LookupRadioField;
+	}
+};
+
+let lookupradiofieldtype = new LookupRadioFieldType("la", "LookupRadioField", "Holds the value of a lookup/radio field of a record (and related information)");
+
+
+export class LookupRadioField extends LookupField
+{
+	[ul4.symbols.type]()
+	{
+		return lookupradiofieldtype;
+	}
+
+	get _sel_label()
+	{
+		return this._sel_root + " label:not([for]) > span";
+	}
+
+	_get_dom_value()
+	{
+		for (let node of this._dom_controls)
+		{
+			if (node.checked)
+			{
+				let key = node.getAttribute("value");
+				return this.control.lookupdata.get(key);
+			}
+
+		}
+		return null;
+	}
+
+	_set_dom_value(value)
+	{
+		if (value instanceof LookupItem)
+			value = value.key;
+		if (value === null)
+			value = this.control.nonekey;
+
+		for (let node of this._dom_controls)
+			node.checked = node.getAttribute("value") === value;
+	}
+
+	_set_dom_lookupdata(lookupdata)
+	{
+		this._set_dom_lookupdata_input(lookupdata);
+	}
+};
+
+
+class LookupSelectFieldType extends LookupFieldType
 {
-	static classdoc = "Holds the value of a lookup field of a record (and related information)";
+	instancecheck(obj)
+	{
+		return obj instanceof LookupSelectField;
+	}
+};
 
-	_validate(change)
+let lookupselectfieldtype = new LookupSelectFieldType("la", "LookupSelectField", "Holds the value of a lookup/select field of a record (and related information)");
+
+
+export class LookupSelectField extends LookupField
+{
+	[ul4.symbols.type]()
 	{
-		let v = change.value;
-		if (v === null || v === "" || this.control.nonekey === v)
-		{
-			if (this.control.required)
-				change.errors.push(this.msg_field_required(v));
-			change.value = null;
-		}
-		else
+		return lookupselectfieldtype;
+	}
+
+	_get_dom_value()
+	{
+		let value = super._get_dom_value();
+		if (value)
 		{
-			this._find_lookupitem(change);
+			if (value === this.control.nonekey)
+				value = null;
+			else
+				value = this.control.lookupdata.get(value);
 		}
+		return value;
+	}
+
+	_set_dom_value(value)
+	{
+		let change = {value: value, errors: []};
+		this._validate(change);
+		super._set_dom_value(change.value != null ? change.value.key : this.control.nonekey);
+	}
+
+	_set_dom_lookupdata(lookupdata)
+	{
+		this._set_dom_lookupdata_select(lookupdata);
+	}
+};
+
+
+class LookupChoiceFieldType extends LookupFieldType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof LookupChoiceField;
+	}
+};
+
+let lookupchoicefieldtype = new LookupChoiceFieldType("la", "LookupChoiceField", "Holds the value of a lookup/choice field of a record (and related information)");
+
+
+export class LookupChoiceField extends LookupField
+{
+	[ul4.symbols.type]()
+	{
+		return lookupchoicefieldtype;
+	}
+};
+
+
+class MultipleLookupFieldType extends LookupFieldBaseType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof MultipleLookupField;
 	}
 };
 
+let multiplelookupfieldtype = new MultipleLookupFieldType("la", "MultipleLookupField", "Holds the value of a multiple lookup field of a record (and related information)");
+
 
 export class MultipleLookupField extends LookupFieldBase
 {
-	static classdoc = "Holds the value of a multiple lookup field of a record (and related information)";
+	[ul4.symbols.type]()
+	{
+		return multiplelookupfieldtype;
+	}
+
+	is_empty()
+	{
+		return this._value.length === 0;
+	}
+
+	value_as_text(maxlevel=3)
+	{
+		let value = this.value;
+		if (value === null || value.length === 0)
+			return null;
+		return value.map(item => item.label).join(", ");
+	}
 
 	_validate(change)
 	{
@@ -1228,14 +2825,151 @@ export class MultipleLookupField extends LookupFieldBase
 };
 
 
-export class AppLookupFieldBase extends Field
+class MultipleLookupCheckboxFieldType extends MultipleLookupFieldType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof MultipleLookupCheckboxField;
+	}
+};
+
+let multiplelookupcheckboxfieldtype = new MultipleLookupCheckboxFieldType("la", "MultipleLookupCheckboxField", "Holds the value of a multiplelookup/radio field of a record (and related information)");
+
+
+export class MultipleLookupCheckboxField extends MultipleLookupField
+{
+	[ul4.symbols.type]()
+	{
+		return multiplelookupcheckboxfieldtype;
+	}
+
+	get _sel_label()
+	{
+		return this._sel_root + " label:not([for]) > span";
+	}
+
+	_get_dom_value()
+	{
+		let value = [];
+		for (let node of this._dom_controls)
+		{
+			if (node.checked)
+			{
+				let key = node.getAttribute("value");
+				value.push(this.control.lookupdata.get(key));
+			}
+
+		}
+		return value;
+	}
+
+	_set_dom_value(value)
+	{
+		let change = {value: value, errors: []};
+		this._validate(change);
+		let values = new Set();
+		for (let value of change.value)
+			values.add(value.key);
+
+		for (let node of this._dom_controls)
+			node.checked = values.has(node.getAttribute("value"));
+	}
+
+	_set_dom_lookupdata(lookupdata)
+	{
+		this._set_dom_lookupdata_input(lookupdata);
+	}
+};
+
+
+class MultipleLookupSelectFieldType extends MultipleLookupFieldType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof MultipleLookupSelectField;
+	}
+};
+
+let multiplelookupselectfieldtype = new MultipleLookupSelectFieldType("la", "MultipleLookupSelectField", "Holds the value of a multiplelookup/select field of a record (and related information)");
+
+export class MultipleLookupSelectField extends MultipleLookupField
+{
+	[ul4.symbols.type]()
+	{
+		return multiplelookupselectfieldtype;
+	}
+
+	_get_dom_value()
+	{
+		let value = [];
+		for (let option of this._dom_control.querySelectorAll("option"))
+		{
+			if (option.selected)
+				value.push(this.control.lookupdata.get(option.getAttribute("value")));
+		}
+		return value;
+	}
+
+	_set_dom_value(value)
+	{
+		let change = {value: value, errors: []};
+		this._validate(change);
+		let values = new Set();
+		for (let value of change.value)
+			values.add(value.key);
+		for (let option of this._dom_control.querySelectorAll("option"))
+			option.selected = values.has(option.getAttribute("value"));
+	}
+
+	_set_dom_lookupdata(lookupdata)
+	{
+		this._set_dom_lookupdata_select(lookupdata);
+	}
+};
+
+
+class MultipleLookupChoiceFieldType extends MultipleLookupFieldType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof MultipleLookupChoiceField;
+	}
+};
+
+let multiplelookupchoicefieldtype = new MultipleLookupChoiceFieldType("la", "MultipleLookupChoiceField", "Holds the value of a multiplelookup/choice field of a record (and related information)");
+
+
+export class MultipleLookupChoiceField extends MultipleLookupField
+{
+	[ul4.symbols.type]()
+	{
+		return multiplelookupchoicefieldtype;
+	}
+};
+
+
+class AppLookupFieldBaseType extends FieldType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof AppLookupFieldBase;
+	}
+};
+
+let applookupfieldbasetype = new AppLookupFieldBaseType("la", "AppLookupFieldBase", "Base type of AppLookupField and MultipleAppLookupField");
+
+
+export class AppLookupFieldBase extends ChoiceFieldBase
 {
-	static classdoc = "Base type of AppLookupField and MultipleAppLookupField";
+	[ul4.symbols.type]()
+	{
+		return applookupfieldbasetype;
+	}
 
 	get lookupdata()
 	{
-		if (this._lookupdate !== null)
-			return this._lookupdate;
+		if (this._lookupdata !== null)
+			return this._lookupdata;
 		else
 		{
 			if (this.control.lookup_app.records !== null)
@@ -1246,7 +2980,23 @@ export class AppLookupFieldBase extends Field
 
 	set lookupdata(value)
 	{
-		this._lookupdate = value;
+		if (this._in_form())
+			this._set_dom_lookupdata(value);
+		this._lookupdata = value;
+	}
+
+	_set_dom_lookupdata(lookupdata)
+	{
+	}
+
+	_make_label(value)
+	{
+		if (typeof(value) === "string")
+			return value;
+		else if (value instanceof Record)
+			return value.as_text(this.control.lookup_controls);
+		else
+			return ul4._str(value);
 	}
 
 	_find_record(change)
@@ -1254,7 +3004,11 @@ export class AppLookupFieldBase extends Field
 		let v = change.value;
 		if (typeof(v) === "string")
 		{
-			let record = this.lookupdata.get(v);
+			let record = this.control.lookup_app.records !== null ?
+				this.control.lookup_app.records.get(v) :
+				undefined
+			;
+
 			if (record === undefined)
 			{
 				change.errors.push(this.msg_applookup_unknownkey(v))
@@ -1279,12 +3033,44 @@ export class AppLookupFieldBase extends Field
 			change.value = null;
 		}
 	}
+
+	[ul4.symbols.setattr](key, value)
+	{
+		if (key === "lookupdata")
+			this.lookupdata = value;
+		else
+			super[ul4.symbols.setattr](key, value);
+	}
+};
+AppLookupFieldBase.prototype._ul4attrs = new Set([...Field.prototype._ul4attrs, "lookupdata"]);
+
+
+
+class AppLookupFieldType extends AppLookupFieldBaseType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof AppLookupField;
+	}
 };
 
+let applookupfieldtype = new AppLookupFieldType("la", "AppLookupField", "Holds the value of a applookup field of a record (and related information)");
+
 
 export class AppLookupField extends AppLookupFieldBase
 {
-	static classdoc = "Holds the value of a applookup field of a record (and related information)";
+	[ul4.symbols.type]()
+	{
+		return applookupfieldtype;
+	}
+
+	value_as_text(maxlevel=3)
+	{
+		let value = this.value;
+		if (value === null)
+			return null;
+		return "(" + this.value.as_text(maxlevel) + ")";
+	}
 
 	_validate(change)
 	{
@@ -1293,9 +3079,115 @@ export class AppLookupField extends AppLookupFieldBase
 };
 
 
+class AppLookupSelectFieldType extends AppLookupFieldType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof AppLookupSelectField;
+	}
+};
+
+let applookupselectfieldtype = new AppLookupSelectFieldType("la", "AppLookupSelectField", "Holds the value of a `applookup`/`select` field of a record (and related information)");
+
+
+export class AppLookupSelectField extends AppLookupField
+{
+	[ul4.symbols.type]()
+	{
+		return applookupselectfieldtype;
+	}
+
+	_get_dom_value()
+	{
+		let value = super._get_dom_value();
+
+		if (this.control.lookup_app.records !== null)
+		{
+			value = this.control.lookup_app.records.get(value);
+			if (value === undefined)
+				value = null;
+		}
+		else
+			value = null;
+		return value;
+	}
+
+	_set_dom_value(value)
+	{
+		let change = {value: value, errors: []};
+		this._validate(change);
+		super._set_dom_value(change.value != null ? change.value.id : this.control.nonekey);
+	}
+
+	_set_dom_lookupdata(lookupdata)
+	{
+		this._set_dom_lookupdata_select(lookupdata);
+	}
+};
+
+
+class AppLookupRadioFieldType extends AppLookupFieldType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof AppLookupRadioField;
+	}
+};
+
+let applookupradiofieldtype = new AppLookupRadioFieldType("la", "AppLookupRadioField", "Holds the value of a `applookup`/`radio` field of a record (and related information)");
+
+
+export class AppLookupRadioField extends AppLookupField
+{
+	[ul4.symbols.type]()
+	{
+		return applookupradiofieldtype;
+	}
+};
+
+
+class AppLookupChoiceFieldType extends AppLookupFieldType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof AppLookupChoiceField;
+	}
+};
+
+let applookupchoicefieldtype = new AppLookupChoiceFieldType("la", "AppLookupChoiceField", "Holds the value of a `applookup`/`choice` field of a record (and related information)");
+
+
+export class AppLookupChoiceField extends AppLookupField
+{
+	[ul4.symbols.type]()
+	{
+		return applookupchoicefieldtype;
+	}
+};
+
+
+class MultipleAppLookupFieldType extends AppLookupFieldBaseType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof MultipleAppLookupField;
+	}
+};
+
+let multipleapplookupfieldtype = new MultipleAppLookupFieldType("la", "MultipleAppLookupField", "Holds the value of a multiple applookup field of a record (and related information)");
+
+
 export class MultipleAppLookupField extends AppLookupFieldBase
 {
-	static classdoc = "Holds the value of a multiple applookup field of a record (and related information)";
+	[ul4.symbols.type]()
+	{
+		return multipleapplookupfieldtype;
+	}
+
+	is_empty()
+	{
+		return this._value.length === 0;
+	}
 
 	_validate(change)
 	{
@@ -1334,8 +3226,89 @@ export class MultipleAppLookupField extends AppLookupFieldBase
 };
 
 
+class MultipleAppLookupCheckboxFieldType extends MultipleAppLookupFieldType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof MultipleAppLookupCheckboxField;
+	}
+};
+
+let multipleapplookupcheckboxfieldtype = new MultipleAppLookupCheckboxFieldType("la", "MultipleAppLookupCheckboxField", "Holds the value of a `multipleapplookup`/`checkbox` field of a record (and related information)");
+
+
+export class MultipleAppLookupCheckboxField extends MultipleAppLookupField
+{
+	[ul4.symbols.type]()
+	{
+		return multipleapplookupcheckboxfieldtype;
+	}
+};
+
+
+class MultipleAppLookupSelectFieldType extends MultipleAppLookupFieldType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof MultipleAppLookupSelectField;
+	}
+};
+
+let multipleapplookupselectfieldtype = new MultipleAppLookupSelectFieldType("la", "MultipleAppLookupSelectField", "Holds the value of a `multipleapplookup`/`select` field of a record (and related information)");
+
+
+export class MultipleAppLookupSelectField extends MultipleAppLookupField
+{
+	[ul4.symbols.type]()
+	{
+		return multipleapplookupselectfieldtype;
+	}
+
+	_set_dom_lookupdata(lookupdata)
+	{
+		this._set_dom_lookupdata_select(lookupdata);
+	}
+};
+
+
+class MultipleAppLookupChoiceFieldType extends MultipleAppLookupFieldType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof MultipleAppLookupChoiceField;
+	}
+};
+
+let multipleapplookupchoicefieldtype = new MultipleAppLookupChoiceFieldType("la", "MultipleAppLookupChoiceField", "Holds the value of a `multipleapplookup`/`choice` field of a record (and related information)");
+
+
+export class MultipleAppLookupChoiceField extends MultipleAppLookupField
+{
+	[ul4.symbols.type]()
+	{
+		return multipleapplookupchoicefieldtype;
+	}
+};
+
+
+class ControlType extends ul4.Type
+{
+	instancecheck(obj)
+	{
+		return obj instanceof Control;
+	}
+};
+
+let controltype = new ControlType("la", "Control", "Metainformation about a field in a LivingApps application");
+
+
 export class Control extends Base
 {
+	[ul4.symbols.type]()
+	{
+		return controltype;
+	}
+
 	[ul4.symbols.repr]()
 	{
 		return "<" + this.constructor.name + " id=" + ul4._repr(this.id) + " identifier=" + ul4._repr(this.identifier) + ">";
@@ -1417,6 +3390,10 @@ export class Control extends Base
 	get mode()
 	{
 		let view_control = this._view_control();
+		if (this.app._active_view !== null && view_control === null)
+			return null;
+		if (this.app.globals.mode === null)
+			return "display";
 		return view_control !== null ? view_control.mode : "edit";
 	}
 
@@ -1471,11 +3448,27 @@ Control.prototype.type = null;
 Control.prototype.subtype = null;
 Control.prototype._ul4onattrs = ["identifier", "fieldname", "app", "_label", "priority", "order", "ininsertprocedure", "inupdateprocedure"];
 Control.prototype._ul4attrs = new Set(["id", "identifier", "fieldname", "app", "priority", "order", "ininsertprocedure", "inupdateprocedure", "fulltype", "label", "top", "left", "width", "height", "liveupdate", "tabindex", "required", "mode", "labelpos", "autoalign", "in_active_view"]);
+Control.prototype._cssclass_root = "llft-control";
+Control.prototype._cssclass_control = "input";
+
+
+class BoolControlType extends ControlType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof BoolControl;
+	}
+};
+
+let boolcontroltype = new BoolControlType("la", "BoolControl", "A LivingApps boolean field (type 'bool')");
 
 
 export class BoolControl extends Control
 {
-	static classdoc = "A LivingApps boolean field (type 'bool')";
+	[ul4.symbols.type]()
+	{
+		return boolcontroltype;
+	}
 
 	// ``search`` must by ``null``, ``false`` or ``true``
 	search(value, search)
@@ -1492,9 +3485,23 @@ BoolControl.prototype.type = "bool";
 BoolControl.prototype.fieldtype = BoolField;
 
 
+class IntControlType extends ControlType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof IntControl;
+	}
+};
+
+let intcontroltype = new IntControlType("la", "IntControl", "A LivingApps integer field (type 'int')");
+
+
 export class IntControl extends Control
 {
-	static classdoc = "A LivingApps integer field (type 'int')";
+	[ul4.symbols.type]()
+	{
+		return intcontroltype;
+	}
 
 	// ``search.value`` must by ``null`` or an integer
 	search(value, search)
@@ -1511,9 +3518,23 @@ IntControl.prototype.type = "int";
 IntControl.prototype.fieldtype = IntField;
 
 
+class PlaceholderControlType extends ControlType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof PlaceholderControld;
+	}
+};
+
+let placeholdercontroltype = new PlaceholderControlType("la", "PlaceholderControl", "A LivingApps field that has a placeholder");
+
+
 class PlaceholderControl extends Control
 {
-	static classdoc = "A LivingApps multiplelookup field (type 'multiplelookup/select')";
+	[ul4.symbols.type]()
+	{
+		return placeholdercontroltype;
+	}
 
 	get placeholder()
 	{
@@ -1527,9 +3548,23 @@ class PlaceholderControl extends Control
 PlaceholderControl.prototype._ul4attrs = new Set([...Control.prototype._ul4attrs, "placeholder"]);
 
 
+class NumberControlType extends PlaceholderControlType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof NumberControl;
+	}
+};
+
+let numbercontroltype = new NumberControlType("la", "NumberControl", "A LivingApps number field (type 'number')");
+
+
 export class NumberControl extends PlaceholderControl
 {
-	static classdoc = "A LivingApps number field (type 'number')";
+	[ul4.symbols.type]()
+	{
+		return numbercontroltype;
+	}
 
 	// ``search.value`` must by ``null`` or an integer
 	search(value, search)
@@ -1550,10 +3585,28 @@ export class NumberControl extends PlaceholderControl
 
 NumberControl.prototype.type = "number";
 NumberControl.prototype.fieldtype = NumberField;
+NumberControl.prototype._ul4onattrs = [...Control.prototype._ul4onattrs, "precision", "minimum", "maximum"];
+NumberControl.prototype._ul4attrs = new Set([...Control.prototype._ul4attrs, "precision", "minimum", "maximum"]);
+
+
+class StringControlType extends PlaceholderControlType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof StringControl;
+	}
+};
+
+let stringcontroltype = new StringControlType("la", "StringControl", "A LivingApps number field (type 'string')");
 
 
 export class StringControl extends PlaceholderControl
 {
+	[ul4.symbols.type]()
+	{
+		return stringcontroltype;
+	}
+
 	_user_placeholder(user, placeholder)
 	{
 		if (placeholder === null)
@@ -1664,45 +3717,138 @@ export class StringControl extends PlaceholderControl
 StringControl.prototype.type = "string";
 
 
+class TextControlType extends StringControlType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof TextControl;
+	}
+};
+
+let textcontroltype = new TextControlType("la", "TextControl", "A LivingApps text field (type 'string/text')");
+
+
 export class TextControl extends StringControl
 {
-	static classdoc = "A LivingApps text field (type 'string/text')";
+	[ul4.symbols.type]()
+	{
+		return textcontroltype;
+	}
 };
 
 TextControl.prototype.subtype = "text";
 TextControl.prototype.fieldtype = StringField;
 
 
+class PasswordControlType extends StringControlType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof PasswordControl;
+	}
+};
+
+let passwordcontroltype = new PasswordControlType("la", "PasswordControl", "A LivingApps password field (type 'string/password')");
+
+
+export class PasswordControl extends StringControl
+{
+	[ul4.symbols.type]()
+	{
+		return passwordcontroltype;
+	}
+};
+
+PasswordControl.prototype.subtype = "password";
+PasswordControl.prototype.fieldtype = PasswordField;
+
+
+class EmailControlType extends StringControlType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof EmailControl;
+	}
+};
+
+let emailcontroltype = new EmailControlType("la", "EmailControl", "A LivingApps email field (type 'string/email')");
+
+
 export class EmailControl extends StringControl
 {
-	static classdoc = "A LivingApps email field (type 'string/email')";
+	[ul4.symbols.type]()
+	{
+		return emailcontroltype;
+	}
 };
 
 EmailControl.prototype.subtype = "email";
 EmailControl.prototype.fieldtype = EmailField;
 
 
+class URLControlType extends StringControlType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof URLControl;
+	}
+};
+
+let urlcontroltype = new URLControlType("la", "URLControl", "A LivingApps URL field (type 'string/url')");
+
+
 export class URLControl extends StringControl
 {
-	static classdoc = "A LivingApps URL field (type 'string/url')";
+	[ul4.symbols.type]()
+	{
+		return urlcontroltype;
+	}
 };
 
 URLControl.prototype.subtype = "url";
 URLControl.prototype.fieldtype = URLField;
 
 
+class TelControlType extends StringControlType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof TelControl;
+	}
+};
+
+let telcontroltype = new TelControlType("la", "TelControl", "A LivingApps phone number field (type 'string/tel')");
+
+
 export class TelControl extends StringControl
 {
-	static classdoc = "A LivingApps phone number field (type 'string/tel')";
+	[ul4.symbols.type]()
+	{
+		return telcontroltype;
+	}
 };
 
 TelControl.prototype.subtype = "tel";
 TelControl.prototype.fieldtype = TelField;
 
 
+class TextAreaControlType extends StringControlType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof TextAreaControl;
+	}
+};
+
+let textareacontroltype = new TextAreaControlType("la", "TextAreaControl", "A LivingApps textarea field (type 'string/textarea')");
+
+
 export class TextAreaControl extends StringControl
 {
-	static classdoc = "A LivingApps textarea field (type 'string/textarea')";
+	[ul4.symbols.type]()
+	{
+		return textareacontroltype;
+	}
 
 	get maxlength()
 	{
@@ -1724,20 +3870,49 @@ TextAreaControl.prototype.subtype = "textarea";
 TextAreaControl.prototype.fieldtype = TextAreaField;
 TextAreaControl.prototype._ul4onattrs = [...StringControl.prototype._ul4onattrs, "encrypted"];
 TextAreaControl.prototype._ul4attrs = new Set([...StringControl.prototype._ul4attrs, "encrypted"]);
+TextAreaControl.prototype._cssclass_control = "textarea";
+
+
+class HTMLControlType extends StringControlType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof HTMLControl;
+	}
+};
+
+let htmlcontroltype = new HTMLControlType("la", "HTMLControl", "A LivingApps HTML field (type 'string/html')");
 
 
 export class HTMLControl extends StringControl
 {
-	static classdoc = "A LivingApps HTML field (type 'string/html')";
+	[ul4.symbols.type]()
+	{
+		return htmlcontroltype;
+	}
 };
 
 HTMLControl.prototype.subtype = "html";
 HTMLControl.prototype.fieldtype = HTMLField;
 
 
+class DateControlType extends PlaceholderControlType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof DateControl;
+	}
+};
+
+let datecontroltype = new DateControlType("la", "DateControl", "A LivingApps date field (type 'date/date')");
+
+
 export class DateControl extends PlaceholderControl
 {
-	static classdoc = "A LivingApps date field (type 'date/date')";
+	[ul4.symbols.type]()
+	{
+		return datecontroltype;
+	}
 
 	get default()
 	{
@@ -1749,14 +3924,25 @@ export class DateControl extends PlaceholderControl
 		return view_control.default === "{today}" ? ul4.today() : null;
 	}
 
-	formatstring(language)
+	formatstring(lang)
 	{
-		language = language || this.app.language;
+		lang = lang || this.globals.lang;
 
-		if (language === "de")
-			return "%d.%m.%Y";
-		else
-			return "%m/%d/%Y";
+		if (lang !== "de" && lang !== "fr" && lang !== "it")
+			lang = "en";
+		return this._formatstrings[lang];
+	}
+
+	formatstrings_parse(lang)
+	{
+		lang = lang || this.globals.lang;
+		if (lang !== "de" && lang !== "fr" && lang !== "it")
+			lang = "en";
+
+		return [
+			...this._formatstrings_parse[lang],
+			...this._formatstrings_parse["intl"]
+		];
 	}
 
 	// searchvalue must be ``null``, a ``Date`` object or a string
@@ -1787,11 +3973,62 @@ export class DateControl extends PlaceholderControl
 DateControl.prototype.type = "date";
 DateControl.prototype.subtype = "date";
 DateControl.prototype.fieldtype = DateField;
+DateControl.prototype._formatstrings = {
+	"de": "%d.%m.%Y",
+	"fr": "%d.%m.%Y",
+	"it": "%d.%m.%Y",
+	"en": "%m/%d/%Y",
+	"intl": "%Y-%m-%d"
+};
+
+let _suffixes = [
+	"",
+	" %H:%M",
+	"T%H:%M",
+	" %H:%M:%S",
+	"T%H:%M:%S",
+	" %H:%M:%S.%f",
+	"T%H:%M:%S.%f",
+	" %H:%M%z",
+	"T%H:%M%z",
+	" %H:%M:%S%z",
+	"T%H:%M:%S%z",
+	" %H:%M:%S.%f%z",
+	"T%H:%M:%S.%f%z",
+	" %H:%M %z",
+	"T%H:%M %z",
+	" %H:%M:%S %z",
+	"T%H:%M:%S %z",
+	" %H:%M:%S.%f %z",
+	"T%H:%M:%S.%f %z"
+]
+
+DateControl.prototype._formatstrings_parse = {
+	"en": _suffixes.map(s => "%m/%d/%Y" + s),
+	"de": _suffixes.map(s => "%d.%m.%Y" + s),
+	"fr": _suffixes.map(s => "%d.%m.%Y" + s),
+	"it": _suffixes.map(s => "%d.%m.%Y" + s),
+	"intl": _suffixes.map(s => "%Y-%m-%d" + s)
+};
+
+
+class DatetimeMinuteControlType extends DateControlType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof DatetimeMinuteControl;
+	}
+};
+
+let datetimeminutecontroltype = new DatetimeMinuteControlType("la", "DatetimeMinuteControl", "A LivingApps date field (type 'date/datetimeminute')");
 
 
 export class DatetimeMinuteControl extends DateControl
 {
-	static classdoc = "A LivingApps date field (type 'date/datetimeminute')";
+	[ul4.symbols.type]()
+	{
+		return datetimeminutecontroltype;
+	}
 
 	get default()
 	{
@@ -1810,25 +4047,36 @@ export class DatetimeMinuteControl extends DateControl
 		else
 			return null;
 	}
+};
 
-	formatstring(language)
-	{
-		language = language || this.app.language;
+DatetimeMinuteControl.prototype.subtype = "datetimeminute";
+DatetimeMinuteControl.prototype.fieldtype = DatetimeMinuteField;
+DatetimeMinuteControl.prototype._formatstrings = {
+	"de": "%d.%m.%Y %H:%M",
+	"fr": "%d.%m.%Y %H:%M",
+	"it": "%d.%m.%Y %H:%M",
+	"en": "%m/%d/%Y %H:%M",
+	"intl": "%Y-%m-%d %H:%M"
+};
 
-		if (language === "de")
-			return "%d.%m.%Y %H:%M";
-		else
-			return "%m/%d/%Y %H:%M";
+
+class DatetimeSecondControlType extends DateControlType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof DatetimeSecondControl;
 	}
 };
 
-DatetimeMinuteControl.prototype.subtype = "datetimeminute";
-DatetimeMinuteControl.prototype.fieldtype = DatetimeMinuteField;
+let datetimesecondcontroltype = new DatetimeSecondControlType("la", "DatetimeSecondControl", "A LivingApps date field (type 'date/datetimesecond')");
 
 
 export class DatetimeSecondControl extends DateControl
 {
-	static classdoc = "A LivingApps date field (type 'date/datetimesecond')";
+	[ul4.symbols.type]()
+	{
+		return datetimesecondcontroltype;
+	}
 
 	get default()
 	{
@@ -1846,24 +4094,37 @@ export class DatetimeSecondControl extends DateControl
 		else
 			return null;
 	}
+};
 
-	formatstring(language)
-	{
-		language = language || this.app.language;
+DatetimeSecondControl.prototype.subtype = "datetimesecond";
+DatetimeSecondControl.prototype.fieldtype = DatetimeSecondField;
+DatetimeSecondControl.prototype._formatstrings = {
+	"de": "%d.%m.%Y %H:%M:%S",
+	"fr": "%d.%m.%Y %H:%M:%S",
+	"it": "%d.%m.%Y %H:%M:%S",
+	"en": "%m/%d/%Y %H:%M:%S",
+	"intl": "%Y-%m-%d %H:%M:%S"
+};
 
-		if (language === "de")
-			return "%d.%m.%Y %H:%M:%S";
-		else
-			return "%m/%d/%Y %H:%M:%S";
+
+class LookupControlType extends ControlType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof LookupControl;
 	}
 };
 
-DatetimeSecondControl.prototype.subtype = "datetimesecond";
-DatetimeSecondControl.prototype.fieldtype = DatetimeSecondField;
+let lookupcontroltype = new LookupControlType("la", "LookupControl", "A LivingApps date field (type 'lookup')");
 
 
 export class LookupControl extends Control
 {
+	[ul4.symbols.type]()
+	{
+		return lookupcontroltype;
+	}
+
 	get default()
 	{
 		let view_control = this._view_control();
@@ -1919,35 +4180,119 @@ LookupControl.prototype._ul4onattrs = [...Control.prototype._ul4onattrs, "lookup
 LookupControl.prototype._ul4attrs = new Set([...Control.prototype._ul4attrs, "lookupdata"]);
 
 
-export class LookupSelectControl extends LookupControl
+class LookupSelectControlType extends LookupControlType
 {
-	static classdoc = "A LivingApps lookup field (type 'lookup/select')";
+	instancecheck(obj)
+	{
+		return obj instanceof LookupSelectControl;
+	}
+};
+
+let lookupselectcontroltype = new LookupSelectControlType("la", "LookupSelectControl", "A LivingApps lookup field (type 'lookup/select')");
 
+
+export class LookupSelectControl extends LookupControl
+{
+	[ul4.symbols.type]()
+	{
+		return lookupselectcontroltype;
+	}
 };
 
 LookupSelectControl.prototype.subtype = "select";
+LookupSelectControl.prototype.fieldtype = LookupSelectField;
+LookupSelectControl.prototype._cssclass_control = "select";
 
 
-export class LookupRadioControl extends LookupControl
+class LookupRadioControlType extends LookupControlType
 {
-	static classdoc = "A LivingApps lookup field (type 'lookup/radio')";
+	instancecheck(obj)
+	{
+		return obj instanceof LookupRadioControl;
+	}
+};
+
+let lookupradiocontroltype = new LookupRadioControlType("la", "LookupRadioControl", "A LivingApps lookup field (type 'lookup/radio')");
 
+
+export class LookupRadioControl extends LookupControl
+{
+	[ul4.symbols.type]()
+	{
+		return lookupradiocontroltype;
+	}
 };
 
 LookupRadioControl.prototype.subtype = "radio";
+LookupRadioControl.prototype.fieldtype = LookupRadioField;
+LookupRadioControl.prototype._cssclass_root = "llft-element";
 
 
-export class LookupChoiceControl extends LookupControl
+class LookupChoiceControlType extends LookupControlType
 {
-	static classdoc = "A LivingApps lookup field (type 'lookup/choice')";
+	instancecheck(obj)
+	{
+		return obj instanceof LookupChoiceControl;
+	}
+};
+
+let lookupchoicecontroltype = new LookupChoiceControlType("la", "LookupChoiceControl", "A LivingApps lookup field (type 'lookup/choice')");
 
+
+export class LookupChoiceControl extends LookupControl
+{
+	[ul4.symbols.type]()
+	{
+		return lookupchoicecontroltype;
+	}
 };
 
 LookupChoiceControl.prototype.subtype = "choice";
+LookupChoiceControl.prototype.fieldtype = LookupChoiceField;
+
+
+class AppLookupControlType extends ControlType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof AppLookupControl;
+	}
+};
+
+let applookupcontroltype = new AppLookupControlType("la", "AppLookupControl", "A LivingApps lookup field (type 'applookup')");
+
+
+export class AppLookupControl extends Control
+{
+	[ul4.symbols.type]()
+	{
+		return applookupcontroltype;
+	}
+
+	get lookupdata()
+	{
+		if (this.lookup_app !== null && this.lookup_app.records !== null)
+			return this.lookup_app.records;
+		else
+			return new Map();
+	}
+
+	get nonekey()
+	{
+		let view_control = this._view_control();
+		if (view_control === null)
+			return null;
+		return view_control.lookupnonekey;
+	}
 
+	get nonelabel()
+	{
+		let view_control = this._view_control();
+		if (view_control === null)
+			return null;
+		return view_control.lookupnonelabel;
+	}
 
-export class AppLookupControl extends Control
-{
 	// ``search.value`` must be an object containing the search criteria for the referenced record
 	search(value, search)
 	{
@@ -1964,35 +4309,94 @@ AppLookupControl.prototype._ul4onattrs = [...Control.prototype._ul4onattrs, "loo
 AppLookupControl.prototype._ul4attrs = new Set([...Control.prototype._ul4attrs, "lookup_app", "lookup_controls", "local_master_control", "local_detail_controls", "remote_master_control"]);
 
 
-export class AppLookupSelectControl extends AppLookupControl
+class AppLookupSelectControlType extends AppLookupControlType
 {
-	static classdoc = "A LivingApps applookup field (type 'applookup/select')";
+	instancecheck(obj)
+	{
+		return obj instanceof AppLookupSelectControl;
+	}
+};
+
+let applookupselectcontroltype = new AppLookupSelectControlType("la", "AppLookupSelectControl", "A LivingApps applookup field (type 'applookup/select')");
 
+
+export class AppLookupSelectControl extends AppLookupControl
+{
+	[ul4.symbols.type]()
+	{
+		return applookupselectcontroltype;
+	}
 };
 
 AppLookupSelectControl.prototype.subtype = "select";
+AppLookupSelectControl.prototype.fieldtype = AppLookupSelectField;
+AppLookupSelectControl.prototype._cssclass_control = "select";
 
 
-export class AppLookupRadioControl extends AppLookupControl
+class AppLookupRadioControlType extends AppLookupControlType
 {
-	static classdoc = "A LivingApps applookup field (type 'applookup/radio')";
+	instancecheck(obj)
+	{
+		return obj instanceof AppLookupRadioControl;
+	}
+};
+
+let applookupradiocontroltype = new AppLookupRadioControlType("la", "AppLookupRadioControl", "A LivingApps applookup field (type 'applookup/radio')");
 
+
+export class AppLookupRadioControl extends AppLookupControl
+{
+	[ul4.symbols.type]()
+	{
+		return applookupradiocontroltype;
+	}
 };
 
 AppLookupRadioControl.prototype.subtype = "radio";
+AppLookupRadioControl.prototype.fieldtype = AppLookupRadioField;
 
 
-export class AppLookupChoiceControl extends AppLookupControl
+class AppLookupChoiceControlType extends AppLookupControlType
 {
-	static classdoc = "A LivingApps applookup field (type 'applookup/choice')";
+	instancecheck(obj)
+	{
+		return obj instanceof AppLookupChoiceControl;
+	}
+};
+
+let applookupchoicecontroltype = new AppLookupChoiceControlType("la", "AppLookupChoiceControl", "A LivingApps applookup field (type 'applookup/choice')");
 
+
+export class AppLookupChoiceControl extends AppLookupControl
+{
+	[ul4.symbols.type]()
+	{
+		return applookupchoicecontroltype;
+	}
 };
 
 AppLookupChoiceControl.prototype.subtype = "choice";
+AppLookupChoiceControl.prototype.fieldtype = AppLookupChoiceField;
+
+
+class MultipleLookupControlType extends LookupControlType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof MultipleLookupControl;
+	}
+};
+
+let multiplelookupcontroltype = new MultipleLookupControlType("la", "MultipleLookupControl", "A LivingApps multiple applookup field (type 'multipleapplookup')");
 
 
 export class MultipleLookupControl extends LookupControl
 {
+	[ul4.symbols.type]()
+	{
+		return multiplelookupcontroltype;
+	}
+
 	get default()
 	{
 		let view_control = this._view_control();
@@ -2022,39 +4426,104 @@ export class MultipleLookupControl extends LookupControl
 	}
 };
 
-MultipleLookupControl.prototype.subtype = "multiplelookup";
+MultipleLookupControl.prototype.type = "multiplelookup";
 MultipleLookupControl.prototype.fieldtype = MultipleLookupField;
 
 
-export class MultipleLookupSelectControl extends MultipleLookupControl
+class MultipleLookupCheckboxControlType extends MultipleLookupControlType
 {
-	static classdoc = "A LivingApps multiplelookup field (type 'multiplelookup/select')";
-
+	instancecheck(obj)
+	{
+		return obj instanceof MultipleLookupCheckboxControl;
+	}
 };
 
-MultipleLookupSelectControl.prototype.subtype = "select";
+let multiplelookupcheckboxcontroltype = new MultipleLookupCheckboxControlType("la", "MultipleLookupCheckboxControl", "A LivingApps multiplelookup field (type 'multiplelookup/checkbox')");
 
 
 export class MultipleLookupCheckboxControl extends MultipleLookupControl
 {
-	static classdoc = "A LivingApps multiplelookup field (type 'multiplelookup/checkbox')";
+	[ul4.symbols.type]()
+	{
+		return multiplelookupcheckboxcontroltype;
+	}
 
+	get _sel_label()
+	{
+		return this._sel_root + " label:not([for]) > span";
+	}
 };
 
 MultipleLookupCheckboxControl.prototype.subtype = "checkbox";
+MultipleLookupCheckboxControl.prototype.fieldtype = MultipleLookupCheckboxField;
+MultipleLookupCheckboxControl.prototype._cssclass_root = "llft-element";
 
 
-export class MultipleLookupChoiceControl extends MultipleLookupControl
+class MultipleLookupSelectControlType extends MultipleLookupControlType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof MultipleLookupSelectControl;
+	}
+};
+
+let multiplelookupselectcontroltype = new MultipleLookupSelectControlType("la", "MultipleLookupSelectControl", "A LivingApps multiplelookup field (type 'multiplelookup/select')");
+
+
+export class MultipleLookupSelectControl extends MultipleLookupControl
+{
+	[ul4.symbols.type]()
+	{
+		return multiplelookupselectcontroltype;
+	}
+};
+
+MultipleLookupSelectControl.prototype.subtype = "select";
+MultipleLookupSelectControl.prototype.fieldtype = MultipleLookupSelectField;
+MultipleLookupSelectControl.prototype._cssclass_control = "select";
+
+
+class MultipleLookupChoiceControlType extends MultipleLookupControlType
 {
-	static classdoc = "A LivingApps multiplelookup field (type 'multiplelookup/choice')";
+	instancecheck(obj)
+	{
+		return obj instanceof MultipleLookupChoiceControl;
+	}
+};
+
+let multiplelookupchoicecontroltype = new MultipleLookupChoiceControlType("la", "MultipleLookupChoiceControl", "A LivingApps multiplelookup field (type 'multiplelookup/choice')");
+
 
+export class MultipleLookupChoiceControl extends MultipleLookupControl
+{
+	[ul4.symbols.type]()
+	{
+		return multiplelookupchoicecontroltype;
+	}
 };
 
 MultipleLookupChoiceControl.prototype.subtype = "choice";
+MultipleLookupChoiceControl.prototype.fieldtype = MultipleLookupChoiceField;
+
+
+class MultipleAppLookupControlType extends AppLookupControlType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof MultipleAppLookupControl;
+	}
+};
+
+let multipleapplookupcontroltype = new MultipleAppLookupControlType("la", "MultipleAppLookupControl", "A LivingApps multiple applookup field (type 'multipleapplookup')");
 
 
 export class MultipleAppLookupControl extends AppLookupControl
 {
+	[ul4.symbols.type]()
+	{
+		return multipleapplookupcontroltype;
+	}
+
 	// ``search.value`` must be an object containing the search criteria for the referenced record
 	search(value, search)
 	{
@@ -2081,69 +4550,186 @@ MultipleAppLookupControl.prototype.type = "multipleapplookup";
 MultipleAppLookupControl.prototype.fieldtype = MultipleAppLookupField;
 
 
-export class MultipleAppLookupSelectControl extends MultipleAppLookupControl
+class MultipleAppLookupSelectControlType extends MultipleAppLookupControlType
 {
-	static classdoc = "A LivingApps multiple applookup field (type 'multipleapplookup/select')";
+	instancecheck(obj)
+	{
+		return obj instanceof MultipleAppLookupSelectControl;
+	}
+};
+
+let multipleapplookupselectcontroltype = new MultipleAppLookupSelectControlType("la", "MultipleAppLookupSelectControl", "A LivingApps multiple applookup field (type 'multipleapplookup/select')");
+
 
+export class MultipleAppLookupSelectControl extends MultipleAppLookupControl
+{
+	[ul4.symbols.type]()
+	{
+		return multipleapplookupselectcontroltype;
+	}
 };
 
 MultipleAppLookupSelectControl.prototype.subtype = "select";
+MultipleAppLookupSelectControl.prototype.fieldtype = MultipleAppLookupSelectField;
+MultipleAppLookupSelectControl.prototype._cssclass_control = "select";
 
 
-export class MultipleAppLookupCheckboxControl extends MultipleAppLookupControl
+class MultipleAppLookupCheckboxControlType extends MultipleAppLookupControlType
 {
-	static classdoc = "A LivingApps multiple applookup field (type 'multipleapplookup/checkbox')";
+	instancecheck(obj)
+	{
+		return obj instanceof MultipleAppLookupCheckboxControl;
+	}
+};
 
+let multipleapplookupcheckboxcontroltype = new MultipleAppLookupCheckboxControlType("la", "MultipleAppLookupCheckboxControl", "A LivingApps multiple applookup field (type 'multipleapplookup/checkbox')");
+
+
+export class MultipleAppLookupCheckboxControl extends MultipleAppLookupControl
+{
+	[ul4.symbols.type]()
+	{
+		return multipleapplookupcheckboxcontroltype;
+	}
 };
 
 MultipleAppLookupCheckboxControl.prototype.subtype = "checkbox";
+MultipleAppLookupCheckboxControl.prototype.fieldtype = MultipleAppLookupCheckboxField;
+
+
+class MultipleAppLookupChoiceControlType extends MultipleAppLookupControlType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof MultipleAppLookupChoiceControl;
+	}
+};
+
+let multipleapplookupchoicecontroltype = new MultipleAppLookupChoiceControlType("la", "MultipleAppLookupChoiceControl", "A LivingApps multiple applookup field (type 'multipleapplookup/choice')");
 
 
 export class MultipleAppLookupChoiceControl extends MultipleAppLookupControl
 {
-	static classdoc = "A LivingApps multiple applookup field (type 'multipleapplookup/choice')";
+	[ul4.symbols.type]()
+	{
+		return multipleapplookupchoicecontroltype;
+	}
 };
 
 MultipleAppLookupChoiceControl.prototype.subtype = "choice";
+MultipleAppLookupChoiceControl.prototype.fieldtype = MultipleAppLookupChoiceField;
+
+
+class GeoControlType extends ControlType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof GeoControl;
+	}
+};
+
+let geocontroltype = new GeoControlType("la", "GeoControl", "A LivingApps geo field (type 'geo')");
 
 
 export class GeoControl extends Control
 {
-	static classdoc = "A LivingApps geo field (type 'geo')";
+	[ul4.symbols.type]()
+	{
+		return geocontroltype;
+	}
 };
 
 GeoControl.prototype.type = "geo";
 GeoControl.prototype.fieldtype = GeoField;
+GeoControl.prototype._cssclass_root = "llft-element";
+
+
+class FileControlType extends ControlType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof FileControl;
+	}
+};
+
+let filecontroltype = new FileControlType("la", "FileControl", "A LivingApps upload field (type 'file')");
 
 
 export class FileControl extends Control
 {
-	static classdoc = "A LivingApps upload field (type 'file')";
+	[ul4.symbols.type]()
+	{
+		return filecontroltype;
+	}
 };
 
 FileControl.prototype.type = "file";
 FileControl.prototype.fieldtype = FileField;
+FileControl.prototype._cssclass_root = "llft-element";
+
+
+class FileSignatureControlType extends FileControlType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof FileSignatureControl;
+	}
+};
+
+let filesignaturecontroltype = new FileSignatureControlType("la", "FileSignatureControl", "A LivingApps signature image field (type 'file/signature')");
 
 
 export class FileSignatureControl extends FileControl
 {
-	static classdoc = "A LivingApps signature image field (type 'file/signature')";
+	[ul4.symbols.type]()
+	{
+		return filesignaturecontroltype;
+	}
 };
 
 FileSignatureControl.prototype.subtype = "signature";
 FileSignatureControl.prototype.fieldtype = FileSignatureField;
 
 
+class ButtonControlType extends ControlType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof ButtonControl;
+	}
+};
+
+let buttoncontroltype = new ButtonControlType("la", "ButtonControl", "A submit button");
+
+
 export class ButtonControl extends Control
 {
+	[ul4.symbols.type]()
+	{
+		return buttoncontroltype;
+	}
 };
 
 ButtonControl.prototype.type = "button";
 
 
+class LookupItemType extends ul4.Type
+{
+	instancecheck(obj)
+	{
+		return obj instanceof LookupItem;
+	}
+};
+
+let lookupitemtype = new LookupItemType("la", "LookupItem", "An option in a lookup control/field");
+
+
 export class LookupItem extends Base
 {
-	static classdoc = "An option in a lookup control/field";
+	[ul4.symbols.type]()
+	{
+		return lookupitemtype;
+	}
 
 	get label()
 	{
@@ -2185,71 +4771,201 @@ export class LookupItem extends Base
 		return null;
 	}
 
-	[ul4.symbols.repr]()
+	[ul4.symbols.repr]()
+	{
+		let repr = "<LookupItem key=" + ul4._repr(this.key) + " label=" + ul4._repr(this.label);
+		if (!this.visible)
+			repr += "visible=False"
+		return repr + ">";
+	}
+};
+
+LookupItem.prototype._ul4onattrs = ["control", "key", "_label"];
+LookupItem.prototype._ul4attrs = new Set(["id", "control", "key", "label"]);
+
+
+class ViewLookupItemType extends ul4.Type
+{
+	instancecheck(obj)
+	{
+		return obj instanceof ViewLookupItem;
+	}
+};
+
+let viewlookupitemtype = new ViewLookupItemType("la", "ViewLookupItem", "View specific information about a lookup item");
+
+
+export class ViewLookupItem extends Base
+{
+	[ul4.symbols.type]()
+	{
+		return viewlookupitemtype;
+	}
+
+	[ul4.symbols.repr]()
+	{
+		let repr = "<ViewLookupItem key=" + ul4._repr(this.key) + " label=" + ul4._repr(this.label);
+		if (!this.visible)
+			repr += " visible=False"
+		return repr + ">";
+	}
+};
+
+ViewLookupItem.prototype._ul4onattrs = ["key", "label", "visible"];
+ViewLookupItem.prototype._ul4attrs = new Set(["key", "label", "visible"]);
+
+
+class LayoutControlType extends ul4.Type
+{
+	instancecheck(obj)
+	{
+		return obj instanceof LayoutControl;
+	}
+};
+
+let layoutcontroltype = new LayoutControlType("la", "LayoutControl", "A decoration in an input form");
+
+
+export class LayoutControl extends Base
+{
+	[ul4.symbols.type]()
+	{
+		return layoutcontroltype;
+	}
+
+	[ul4.symbols.repr]()
+	{
+		return "<" + this.constructor.name + " id=" + ul4._repr(this.id) + " identifier=" + ul4._repr(this.identifier) + ">";
+	}
+
+	get globals()
+	{
+		return this.view.app.globals;
+	}
+
+	get _sel_root()
+	{
+		return "#livingapps-form .llft-element.llft-id-" + this.identifier;
+	}
+
+	get _dom_root()
+	{
+		return document.querySelector(this._sel_root);
+	}
+};
+
+LayoutControl.prototype._ul4onattrs = ["label", "identifier", "view", "top", "left", "width", "height"];
+LayoutControl.prototype._ul4attrs = new Set(["id", "label", "identifier", "view", "top", "left", "width", "height"]);
+
+
+class HTMLLayoutControlType extends LayoutControlType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof HTMLLayoutControl;
+	}
+};
+
+let htmllayoutcontroltype = new HTMLLayoutControlType("la", "HTMLLayoutControl", "HTML decoration in an input form");
+
+
+export class HTMLLayoutControl extends LayoutControl
+{
+	[ul4.symbols.type]()
+	{
+		return htmllayoutcontroltype;
+	}
+
+	get value()
+	{
+		return this._value;
+	}
+
+	set value(value)
+	{
+		this._value = value;
+		if (this.globals._in_form())
+			this._set_dom_value(this._value);
+	}
+
+	_set_dom_value(value)
 	{
-		let repr = "<LookupItem key=" + ul4._repr(this.key) + " label=" + ul4._repr(this.label);
-		if (!this.visible)
-			repr += "visible=False"
-		return repr + ">";
+		this._dom_root.innerHTML = value;
+	}
+
+	[ul4.symbols.setattr](name, value)
+	{
+		if (name === "value")
+			this.value = value;
+		else
+			return super[ul4.symbols.getattr](name);
 	}
 };
 
-LookupItem.prototype._ul4onattrs = ["control", "key", "_label"];
-LookupItem.prototype._ul4attrs = new Set(["id", "control", "key", "label"]);
+HTMLLayoutControl.prototype._ul4onattrs = [...LayoutControl.prototype._ul4onattrs, "_value"];
+HTMLLayoutControl.prototype._ul4attrs = new Set([...LayoutControl.prototype._ul4attrs, "value"]);
 
 
-export class ViewLookupItem extends Base
+class ImageLayoutControlType extends LayoutControlType
 {
-	static classdoc = "View specific information about a lookup item";
-
-	[ul4.symbols.repr]()
+	instancecheck(obj)
 	{
-		let repr = "<ViewLookupItem key=" + ul4._repr(this.key) + " label=" + ul4._repr(this.label);
-		if (!this.visible)
-			repr += " visible=False"
-		return repr + ">";
+		return obj instanceof ImageLayoutControl;
 	}
 };
 
-ViewLookupItem.prototype._ul4onattrs = ["key", "label", "visible"];
-ViewLookupItem.prototype._ul4attrs = new Set(["key", "label", "visible"]);
+let imagelayoutcontroltype = new ImageLayoutControlType("la", "ImageLayoutControl", "An image decoration in an input form");
 
 
-export class LayoutControl extends Base
+export class ImageLayoutControl extends LayoutControl
 {
-	static classdoc = "A decoration in an input form";
-
-	[ul4.symbols.repr]()
+	[ul4.symbols.type]()
 	{
-		return "<" + this.constructor.name + " id=" + ul4._repr(this.id) + " identifier=" + ul4._repr(this.identifier) + ">";
+		return imagelayoutcontroltype;
 	}
 };
 
-LayoutControl.prototype._ul4onattrs = ["label", "identifier", "view", "top", "left", "width", "height"];
-LayoutControl.prototype._ul4attrs = new Set(["id", "label", "identifier", "view", "top", "left", "width", "height"]);
+ImageLayoutControl.prototype._ul4onattrs = [...LayoutControl.prototype._ul4onattrs, "original", "scaled"];
+ImageLayoutControl.prototype._ul4attrs = new Set([...LayoutControl.prototype._ul4attrs, "original", "scaled"]);
 
 
-export class HTMLLayoutControl extends LayoutControl
+class ButtonLayoutControlType extends LayoutControlType
 {
-	static classdoc = "An HTML decoration in an input form";
+	instancecheck(obj)
+	{
+		return obj instanceof ButtonLayoutControl;
+	}
 };
 
-HTMLLayoutControl.prototype._ul4onattrs = [...LayoutControl.prototype._ul4onattrs, "value"];
-HTMLLayoutControl.prototype._ul4attrs = new Set([LayoutControl.prototype._ul4attrs, "value"]);
+let buttonlayoutcontroltype = new ButtonLayoutControlType("la", "ButtonLayoutControl", "A submit button in an input form");
 
 
-export class ImageLayoutControl extends LayoutControl
+export class ButtonLayoutControl extends LayoutControl
+{
+	[ul4.symbols.type]()
+	{
+		return buttonlayoutcontroltype;
+	}
+};
+
+
+class ViewControlType extends ul4.Type
 {
-	static classdoc = "An image decoration in an input form";
+	instancecheck(obj)
+	{
+		return obj instanceof ViewControl;
+	}
 };
 
-ImageLayoutControl.prototype._ul4onattrs = [...LayoutControl.prototype._ul4onattrs, "original", "scaled"];
-ImageLayoutControl.prototype._ul4attrs = new Set([LayoutControl.prototype._ul4attrs, "original", "scaled"]);
+let viewcontroltype = new ViewControlType("la", "ViewControl", "Contains view specific information about a control");
 
 
 export class ViewControl extends Base
 {
-	static classdoc = "Contains view specific information aboutn a control";
+	[ul4.symbols.type]()
+	{
+		return viewcontroltype;
+	}
 
 	get mode()
 	{
@@ -2261,9 +4977,23 @@ ViewControl.prototype._ul4onattrs = ["view", "control", "top", "left", "width",
 ViewControl.prototype._ul4attrs = new Set(["id", "view", "control", "top", "left", "width", "height", "liveupdate", "default", "tabindex", "minlength", "maxlength", "required", "placeholder", "mode", "labelpos", "lookupnonekey", "lookupnonelabel", "label", "autoalign", "labelwidth", "lookupdata", "autoexpandable"]);
 
 
+class UserType extends ul4.Type
+{
+	instancecheck(obj)
+	{
+		return obj instanceof User;
+	}
+};
+
+let usertype = new UserType("la", "User", "A LivingApps user/account");
+
+
 export class User extends Base
 {
-	static classdoc = "A LivingApps user/account";
+	[ul4.symbols.type]()
+	{
+		return usertype;
+	}
 
 	[ul4.symbols.repr]()
 	{
@@ -2275,25 +5005,60 @@ User.prototype._ul4onattrs = ["_id", "gender", "title", "firstname", "surname",
 User.prototype._ul4attrs = new Set(["id", "_id", "gender", "title", "firstname", "surname", "initials", "email", "streetname", "streetnumber", "zip", "city", "phone", "fax", "lang", "avatarsmall", "avatarlarge", "summary", "interests", "personalwebsite", "companywebsite", "company", "position", "department", "keyviews"]);
 
 
+class FileType extends ul4.Type
+{
+	instancecheck(obj)
+	{
+		return obj instanceof File;
+	}
+};
+
+let filetype = new FileType("la", "File", "An uploaded file");
+
+
 export class File extends Base
 {
-	static classdoc = "An uploaded file";
+	[ul4.symbols.type]()
+	{
+		return filetype;
+	}
 
 	[ul4.symbols.repr]()
 	{
 		return "<File id=" + ul4._repr(this.id) + " url=" + ul4._repr(this.url) + " filename=" + ul4._repr(this.filename) + ">";
 	}
+
+	get url()
+	{
+		return "/gateway/files/" + this.id;
+	}
+
+	get archive_url()
+	{
+		if (this.archive === null)
+			return this.url;
+		return this.archive.url + "/" + this.filename;
+	}
 };
 
-File.prototype._ul4onattrs = ["url", "filename", "mimetype", "width", "height", "internalid", "createdat", "size"];
-File.prototype._ul4attrs = new Set(["id", "url", "filename", "mimetype", "width", "height", "size", "createdat"]);
+File.prototype._ul4onattrs = ["filename", "mimetype", "width", "height", "internalid", "createdat", "size", "duration", "geo", "storagefilename", "archive"];
+File.prototype._ul4attrs = new Set(["id", "url", "archive_url", "filename", "mimetype", "width", "height", "size", "duration", "geo", "archive", "createdat"]);
 
 
-export class Geo extends Base
+class GeoType extends ul4.Type
 {
-	static classdoc = "Geographical coordinates and location information";
+	instancecheck(obj)
+	{
+		return obj instanceof Geo;
+	}
+};
+
+let geotype = new GeoType("la", "Geo", "Geographical coordinates and location information");
+
 
-	constructor(lat, long, info)
+export class Geo extends Base
+{
+	constructor(lat, long, info=null)
 	{
 		super(null);
 		this.lat = lat;
@@ -2301,6 +5066,11 @@ export class Geo extends Base
 		this.info = info;
 	}
 
+	[ul4.symbols.type]()
+	{
+		return geotype;
+	}
+
 	[ul4.symbols.repr]()
 	{
 		return "<Geo lat=" + ul4._repr(this.lat) + " long=" + ul4._repr(this.long) + " info=" + ul4._repr(this.info) + ">";
@@ -2311,8 +5081,24 @@ Geo.prototype._ul4onattrs = ["lat", "long", "info"];
 Geo.prototype._ul4attrs = new Set(["lat", "long", "info"]);
 
 
+class AttachmentType extends ul4.Type
+{
+	instancecheck(obj)
+	{
+		return obj instanceof Attachment;
+	}
+};
+
+let attachmenttype = new AttachmentType("la", "Attachment", "An attachment of a record");
+
+
 export class Attachment extends Base
 {
+	[ul4.symbols.type]()
+	{
+		return attachmenttype;
+	}
+
 	[ul4.symbols.repr]()
 	{
 		return "<" + this.constructor.name + " id=" + ul4._repr(this.id) + " label=" + ul4._repr(this.label) + ">";
@@ -2323,10 +5109,23 @@ Attachment.prototype._ul4onattrs = ["record", "label", "active"];
 Attachment.prototype._ul4attrs = new Set(["id", "record", "label", "active"]);
 
 
-export class NoteAttachment extends Attachment
+class NoteAttachmentType extends AttachmentType
 {
-	static classdoc = "A note attachment of a record";
+	instancecheck(obj)
+	{
+		return obj instanceof NoteAttachment;
+	}
+};
+
+let noteattachmenttype = new NoteAttachmentType("la", "NoteAttachment", "A note attachment of a record");
 
+
+export class NoteAttachment extends Attachment
+{
+	[ul4.symbols.type]()
+	{
+		return noteattachmenttype;
+	}
 };
 
 NoteAttachment.prototype.type = "noteattachment";
@@ -2334,10 +5133,23 @@ NoteAttachment.prototype._ul4onattrs = [...Attachment.prototype._ul4onattrs, "va
 NoteAttachment.prototype._ul4attrs = new Set([...Attachment.prototype._ul4onattrs, "value"]);
 
 
-export class URLAttachment extends Attachment
+class URLAttachmentType extends AttachmentType
 {
-	static classdoc = "A URL attachment of a record";
+	instancecheck(obj)
+	{
+		return obj instanceof URLAttachment;
+	}
+};
+
+let urlattachmenttype = new URLAttachmentType("la", "URLAttachment", "A URL attachment of a record");
 
+
+export class URLAttachment extends Attachment
+{
+	[ul4.symbols.type]()
+	{
+		return urlattachmenttype;
+	}
 };
 
 URLAttachment.prototype.type = "urlattachment";
@@ -2345,10 +5157,23 @@ URLAttachment.prototype._ul4onattrs = [...Attachment.prototype._ul4onattrs, "val
 URLAttachment.prototype._ul4attrs = new Set([...Attachment.prototype._ul4onattrs, "value"]);
 
 
-export class FileAttachment extends Attachment
+class FileAttachmentType extends AttachmentType
 {
-	static classdoc = "A file attachment of a record";
+	instancecheck(obj)
+	{
+		return obj instanceof FileAttachment;
+	}
+};
+
+let fileattachmenttype = new FileAttachmentType("la", "FileAttachment", "A file attachment of a record");
 
+
+export class FileAttachment extends Attachment
+{
+	[ul4.symbols.type]()
+	{
+		return fileattachmenttype;
+	}
 };
 
 FileAttachment.prototype.type = "fileattachment";
@@ -2356,10 +5181,23 @@ FileAttachment.prototype._ul4onattrs = [...Attachment.prototype._ul4onattrs, "va
 FileAttachment.prototype._ul4attrs = new Set([...Attachment.prototype._ul4onattrs, "value"]);
 
 
-export class ImageAttachment extends Attachment
+class ImageAttachmentType extends AttachmentType
 {
-	static classdoc = "An image attachment of a record";
+	instancecheck(obj)
+	{
+		return obj instanceof ImageAttachment;
+	}
+};
+
+let imageattachmenttype = new ImageAttachmentType("la", "ImageAttachment", "An image attachment of a record");
 
+
+export class ImageAttachment extends Attachment
+{
+	[ul4.symbols.type]()
+	{
+		return imageattachmenttype;
+	}
 };
 
 ImageAttachment.prototype.type = "imageattachment";
@@ -2367,9 +5205,23 @@ ImageAttachment.prototype._ul4onattrs = [...Attachment.prototype._ul4onattrs, "o
 ImageAttachment.prototype._ul4attrs = new Set([...Attachment.prototype._ul4onattrs, "original", "thumb", "small", "medium", "large"]);
 
 
+class JSONAttachmentType extends AttachmentType
+{
+	instancecheck(obj)
+	{
+		return obj instanceof JSONAttachment;
+	}
+};
+
+let jsonattachmenttype = new JSONAttachmentType("la", "JSONAttachment", "A JSON attachment of a record");
+
+
 export class JSONAttachment extends Attachment
 {
-	static classdoc = "A JSON attachment of a record";
+	[ul4.symbols.type]()
+	{
+		return jsonattachmenttype;
+	}
 
 	_dumpUL4ONAttr(name)
 	{
@@ -2393,9 +5245,23 @@ JSONAttachment.prototype._ul4onattrs = [...Attachment.prototype._ul4onattrs, "va
 JSONAttachment.prototype._ul4attrs = new Set([...Attachment.prototype._ul4onattrs, "value"]);
 
 
+class InstallationType extends ul4.Type
+{
+	instancecheck(obj)
+	{
+		return obj instanceof Installation;
+	}
+};
+
+let installationtype = new InstallationType("la", "Installation", "The installation that created an app");
+
+
 export class Installation extends Base
 {
-	static classdoc = "The installation that created an app";
+	[ul4.symbols.type]()
+	{
+		return installationtype;
+	}
 
 	[ul4.symbols.repr]()
 	{
@@ -2407,9 +5273,23 @@ Installation.prototype._ul4onattrs = ["name"];
 Installation.prototype._ul4attrs = new Set(["id", "name"]);
 
 
+class CategoryType extends ul4.Type
+{
+	instancecheck(obj)
+	{
+		return obj instanceof Category;
+	}
+};
+
+let categorytype = new CategoryType("la", "Category", "A navigation category");
+
+
 export class Category extends Base
 {
-	static classdoc = "A navigation category";
+	[ul4.symbols.type]()
+	{
+		return categorytype;
+	}
 
 	[ul4.symbols.repr]()
 	{
@@ -2428,9 +5308,23 @@ Category.prototype._ul4onattrs = ["identifier", "name", "order", "parent", "chil
 Category.prototype._ul4attrs = new Set(["id", "identifier", "name", "order", "parent", "children", "apps"]);
 
 
+class KeyViewType extends ul4.Type
+{
+	instancecheck(obj)
+	{
+		return obj instanceof KeyView;
+	}
+};
+
+let keyviewtype = new KeyViewType("la", "KeyView", "Object granting access to a view template");
+
+
 export class KeyView extends Base
 {
-	static classdoc = "Object granting access to a view template";
+	[ul4.symbols.type]()
+	{
+		return keyviewtype;
+	}
 
 	[ul4.symbols.repr]()
 	{
@@ -2442,9 +5336,23 @@ KeyView.prototype._ul4onattrs = ["identifier", "name", "key", "user"];
 KeyView.prototype._ul4attrs = new Set(["id", "identifier", "name", "key", "user"]);
 
 
+class AppParameterType extends ul4.Type
+{
+	instancecheck(obj)
+	{
+		return obj instanceof AppParameter;
+	}
+};
+
+let appparametertype = new AppParameterType("la", "AppParameter", "A parameter of a LivingApps application");
+
+
 export class AppParameter extends Base
 {
-	static classdoc = "A parameter of a LivingApps application";
+	[ul4.symbols.type]()
+	{
+		return appparametertype;
+	}
 
 	[ul4.symbols.repr]()
 	{
@@ -2456,12 +5364,175 @@ AppParameter.prototype._ul4onattrs = ["app", "identifier", "description", "value
 AppParameter.prototype._ul4attrs = new Set(["id", "app", "identifier", "description", "value"]);
 
 
+class FormType extends ul4.Type
+{
+	instancecheck(obj)
+	{
+		return obj instanceof Form;
+	}
+};
+
+let formtype = new FormType("la", "Form", "The input form.");
+
+export class Form extends ul4.Proto
+{
+	constructor(globals, template)
+	{
+		super();
+		this.globals = globals;
+		this.template = template;
+		this._geo_wired = false;
+
+		for (let field of globals.record.fields.values())
+			this.wire_field(field);
+		this.render_template(null);
+	}
+
+	[ul4.symbols.type]()
+	{
+		return formtype;
+	}
+
+	get _dom_button()
+	{
+		return document.querySelector(this._sel_form + " " + this._sel_button);
+	}
+
+	get enabled()
+	{
+		return !this._dom_button.disabled;
+	}
+
+	set enabled(value)
+	{
+		this._dom_button.disabled = !value;
+	}
+
+	[ul4.symbols.getattr](key)
+	{
+		if (key === "enabled")
+			return this.enabled;
+		else
+			throw new ul4.AttributeError(this, key);
+	}
+
+	[ul4.symbols.setattr](key, value)
+	{
+		if (key === "enabled")
+			this.enabled = ul4._bool(value);
+		else
+			throw new ul4.AttributeError(this, key);
+	}
+
+	[ul4.symbols.repr]()
+	{
+		return "<" + this.constructor.name + " enabled=" + ul4._repr(this.enabled) + ">";
+	}
+
+	toString()
+	{
+		return this[ul4.symbols.repr]();
+	}
+
+	render_template(identifier)
+	{
+		let vars = {
+			"record": this.globals.record,
+			"fields": this.globals.record.fields,
+			"identifier": identifier
+		};
+
+		let globalVars = {
+			"globals": this.globals,
+			"form": this,
+			"la": module
+		};
+
+		let msg = "LivingApps update template: ";
+		if (identifier === null)
+			msg += "Initialization";
+		else
+			msg += "Value change in " + ul4._repr(identifier);
+
+		this.globals.group_logging(msg, () => {
+			try
+			{
+				this.template.renders(vars, globalVars);
+			}
+			catch (exc)
+			{
+				if (console && console.error)
+				{
+					this.globals._start_log_message();
+					if (console.group)
+						console.group("UL4 stacktrace");
+					ul4.report_exc(exc);
+					if (console.groupEnd)
+						console.groupEnd();
+
+					if (console.groupCollapsed)
+						console.groupCollapsed("Javascript stacktrace");
+					console.error(exc);
+					if (console.groupEnd)
+						console.groupEnd();
+				}
+			}
+		});
+	}
+
+	wire_geo()
+	{
+		if (this._geo_wired)
+			return;
+
+		if (this.globals.app.active_view !== null && navigator.geolocation)
+		{
+			let use_geo = this.globals.app.active_view.use_geo;
+			if (use_geo === "once" || use_geo === "watch")
+			{
+				navigator.geolocation.getCurrentPosition((position) => {
+					this.globals.mode = this.globals.mode.substring(0, this.globals.mode.lastIndexOf("/") + 1) + "geo";
+					this.globals.set_current_geo(position);
+					this.render_template(null);
+				});
+			}
+
+			if (use_geo === "watch")
+			{
+				navigator.geolocation.watchPosition((position) => {
+					this.globals.mode = this.globals.mode.substring(0, this.globals.mode.lastIndexOf("/") + 1) + "geo";
+					this.globals.set_current_geo(position);
+					this.render_template(null);
+				});
+			}
+		}
+		this._geo_wired = true;
+	}
+
+	wire_field(field)
+	{
+		for (let dom_node of field._dom_controls)
+		{
+			dom_node.addEventListener(field._inputevent, (event) => {
+				this.wire_geo();
+				this.globals.mode = this.globals.mode.substring(0, this.globals.mode.lastIndexOf("/") + 1) + "input";
+				this.render_template(field.control.identifier);
+			});
+		}
+	}
+};
+
+Form.prototype._ul4attrs = new Set(["enabled"]);
+Form.prototype._sel_form = "#livingapps-form form";
+Form.prototype._sel_button = "[type=submit]";
+
+
 let classes = [
 	Globals,
 	FlashMessage,
 	App,
 	View,
-	DataSourceData,
+	DataSource,
 	Record,
 	BoolControl,
 	IntControl,
@@ -2522,6 +5593,7 @@ let classes = [
 	LayoutControl,
 	HTMLLayoutControl,
 	ImageLayoutControl,
+	ButtonLayoutControl,
 	ViewControl,
 	User,
 	File,
@@ -2541,3 +5613,62 @@ for (let constructor of classes)
 {
 	ul4.register("de.livinglogic.livingapi." + constructor.name.toLowerCase(), constructor);
 }
+
+export const module = new ul4.Module(
+	"la",
+	"LivingAPI types",
+	{
+		FlashMessage: FlashMessage,
+		File: File,
+		Geo: Geo,
+		User: User,
+		KeyView: KeyView,
+		Globals: Globals,
+		App: App,
+		TextControl: TextControl,
+		URLControl: URLControl,
+		EmailControl: EmailControl,
+		PasswordControl: PasswordControl,
+		TelControl: TelControl,
+		TextAreaControl: TextAreaControl,
+		HTMLControl: HTMLControl,
+		IntControl: IntControl,
+		NumberControl: NumberControl,
+		DateControl: DateControl,
+		DatetimeMinuteControl: DatetimeMinuteControl,
+		DatetimeSecondControl: DatetimeSecondControl,
+		BoolControl: BoolControl,
+		LookupSelectControl: LookupSelectControl,
+		LookupRadioControl: LookupRadioControl,
+		LookupChoiceControl: LookupChoiceControl,
+		AppLookupSelectControl: AppLookupSelectControl,
+		AppLookupRadioControl: AppLookupRadioControl,
+		AppLookupChoiceControl: AppLookupChoiceControl,
+		MultipleLookupSelectControl: MultipleLookupSelectControl,
+		MultipleLookupCheckboxControl: MultipleLookupCheckboxControl,
+		MultipleLookupChoiceControl: MultipleLookupChoiceControl,
+		MultipleAppLookupSelectControl: MultipleAppLookupSelectControl,
+		MultipleAppLookupCheckboxControl: MultipleAppLookupCheckboxControl,
+		MultipleAppLookupChoiceControl: MultipleAppLookupChoiceControl,
+		FileControl: FileControl,
+		FileSignatureControl: FileSignatureControl,
+		GeoControl: GeoControl,
+		ViewControl: ViewControl,
+		Record: Record,
+		ImageAttachment: ImageAttachment,
+		FileAttachment: FileAttachment,
+		URLAttachment: URLAttachment,
+		NoteAttachment: NoteAttachment,
+		JSONAttachment: JSONAttachment,
+		Installation: Installation,
+		HTMLLayoutControl: HTMLLayoutControl,
+		ImageLayoutControl: ImageLayoutControl,
+		ButtonLayoutControl: ButtonLayoutControl,
+		View: View,
+		DataSource: DataSource,
+		LookupItem: LookupItem,
+		ViewLookupItem: ViewLookupItem,
+		Category: Category,
+		AppParameter: AppParameter,
+	}
+);