// setup namespace
Zymonic.Form = {};

// base form
// don't do anything here, makes it easy to establish inheritance
Zymonic.Form.Form = function() {};

// setup some constants
Zymonic.Field.Field.prototype.FIELD_CHANGED_CLASS = "ZymonicFieldChanged";

// setup some constants
Zymonic.Form.Form.prototype.SYNC_UPDATE_TYPES = { "Update": true, "Insert": true, "UpdateOrInsert": true, "InsertIfNotFound": true, "Delete": true };
Zymonic.Form.Form.prototype.SYNC_UPDATE_TYPES_TO_ADD_RECORDS = { "Insert": true, };
Zymonic.Form.Form.prototype.SYNC_UPDATE_TYPES_TO_DELETE_RECORDS = { "Delete": true, };
Zymonic.Form.Form.prototype.SYNC_UPDATE_TYPES_TO_LOOKUP_RECORDS = { "Update": true, "UpdateOrInsert": true, "InsertIfNotFound": true, "Delete": true };
Zymonic.Form.Form.prototype.SYNC_UPDATE_TYPES_TO_ADD_RECORD_IF_NOT_FOUND = { "UpdateOrInsert": true, "InsertIfNotFound": true, };
Zymonic.Form.Form.prototype.SYNC_UPDATE_TYPES_TO_SKIP_RECORD_IF_FOUND = { "InsertIfNotFound": true, };
Zymonic.Form.Form.prototype.SYNC_UPDATE_TYPES_TO_DELETE_BEFORE_SYNC = { "Insert": true, };
Zymonic.Form.Form.prototype.SYNC_UPDATE_TYPES_TO_DELETE_AFTER_SYNC= { "Update": true, "UpdateOrInsert": true, };
Zymonic.Form.Form.prototype.PLACEHOLDER_ID = 'ZZNEW';

// init function
Zymonic.Form.Form.prototype.init = function(args) {
	for (var key in args) {
		this[key] = args[key];
	}
    
	if (this.ident != "") {
		Zymonic.add_to_lookup('Form', this.ident, this);
	}
	this.field_groups = {};
	this.form_search_fields = [];
	
	this.resetHandlers();
	
	// add placeholder record if needed, do this on ready to let everything get setup
	// can have a race condition here as we need this to run as soon as the form is fully
	// displayed, including any extra js rendering needed, e.g. fieldgroup tabs
	// so we trigger it from a custom form ready event, which gets triggered when all 
	// records in form have completed rendering
	if ( this.use_js_adding && !this.no_add && this.multiple_records ) {
		var form = this;
		Zymonic.Utils.attach_event(
			this,
			'ready_'+this.ident,
			'ready_'+this.ident,
			function() {
				// find the existing placeholder and remove it
				var placeholder_record_html = form.getContainerDiv(" .ZymonicJSPlaceholderRecord");
				placeholder_record_html.detach();
				form.setupPlaceholder.call(form, placeholder_record_html);
			}
		);
	}
	
	// confirm loading of any records on the GUI
	Zymonic.Utils.attach_event(
		this,
		'record_ready_'+this.ident,
		'record_ready_'+this.ident,
		function(event, form, record_ident) {
			var record = form.getRecord(record_ident);
			if (!record) {
				Zymonic.log("Unable to find ready record: "+record_ident);
				return;
			}
			if (record.ready) {
				return;
			}
			record.ready = true;
			
			// if all records are ready trigger the form as ready
			var records = form.getRecords();
			var ready = true;
			for (var i = 0; i < records.length; i++) {
				if (!records[i].ready){
					ready = false;
					break;
				}
			}
			if (ready) {
				Zymonic.Utils.trigger_event( form, 'ready_'+form.ident, null, [form] );
			}
		}
	);
	
	// horizontal forms load automatically, ready all records 
	if (this.isHorizontal()) {
		var formobj = this;
		var records = this.getRecords();
		for (var i = 0; i < records.length; i++) {
			Zymonic.Utils.trigger_event( formobj, 'record_ready_'+formobj.ident, null, [ formobj, records[i].record_ident ] );
		}

		this.resizeobserver = new ResizeObserver( entries => {
			entries.forEach(
				entry => {
					/* Log left commented out just in case... */
					/* console.log("RESULTSIZE: " + formobj.resultsize + " - clientwidth: " + entry.target.clientWidth + " - resultmode: " + formobj.resultmode); */
					/* if(!formobj.resultsize || 
					  ( formobj.resultsize < entry.target.clientWidth && formobj.resultmode != 'normal' ) || 
					  ( formobj.resultsize > entry.target.clientWidth && formobj.resultmode != 'narrow' )  ) 
					{
						formobj.resultSizeHandler(false);
					} */
					/* Going to try a 'dwell' variant with reset - to deal with Safari not actually auto fitting columns when the layout shrinks (only grows?!?) */
					clearTimeout(formobj.resizehandle);
					formobj.resizehandle = setTimeout(function() { formobj.resultSizeHandler(true); }, 300);
				}
			);
	
		});
		
		// Cache this first to ensure resultSizeHandler doesn't think its been changed.
		this.reportlayoutmode = $('input[name="' + this.ident + 'reportlayoutmode"]:checked').val();

		if(div_to_observe) {
			var div_to_observe = document.getElementById( this.ident + "_div");
		
			this.resizeobserver.observe(div_to_observe);
		
			this.resultSizeHandler(true);
		
			$('#' + this.ident + "reportlayoutmode_narrow").on('change', function() {
				formobj.resultSizeHandler(true);
			});
			$('#' + this.ident + "reportlayoutmode_normal").on('change', function() {
				formobj.resultSizeHandler(true);
			});
			$('#' + this.ident + "reportlayoutmode_auto").on('change', function() {
				formobj.resultSizeHandler(true);
			});
		}
	}
};

Zymonic.Form.Form.prototype.docReadyHandler = function() {
	if (this.isHorizontal()) {
		var formobj = this;

		this.resizeobserver = new ResizeObserver( entries => {
			entries.forEach(
				entry => {
					/* Log left commented out just in case... */
					/* console.log("RESULTSIZE: " + formobj.resultsize + " - clientwidth: " + entry.target.clientWidth + " - resultmode: " + formobj.resultmode); */
					/* if(!formobj.resultsize || 
					  ( formobj.resultsize < entry.target.clientWidth && formobj.resultmode != 'normal' ) || 
					  ( formobj.resultsize > entry.target.clientWidth && formobj.resultmode != 'narrow' )  ) 
					{
						formobj.resultSizeHandler(false);
					} */
					/* Going to try a 'dwell' variant with reset - to deal with Safari not actually auto fitting columns when the layout shrinks (only grows?!?) */
					clearTimeout(formobj.resizehandle);
					formobj.resizehandle = setTimeout(function() { formobj.resultSizeHandler(true); }, 300);
				}
			);
	
		});
		
		// Cache this first to ensure resultSizeHandler doesn't think its been changed.
		this.reportlayoutmode = $('input[name="' + this.ident + 'reportlayoutmode"]:checked').val();
	
		this.resizeobserver.observe(document.getElementById( this.ident + "_div"));
	
		this.resultSizeHandler(true);
	
		$('#' + this.ident + "reportlayoutmode_narrow").on('change', function() {
			formobj.resultSizeHandler(true);
		});
		$('#' + this.ident + "reportlayoutmode_normal").on('change', function() {
			formobj.resultSizeHandler(true);
		});
		$('#' + this.ident + "reportlayoutmode_auto").on('change', function() {
			formobj.resultSizeHandler(true);
		});
	}
};

// Report result size handler
Zymonic.Form.Form.prototype.resultSizeHandler = function(reset) {
	var resultModeBefore = this.resultmode;
	this.reportlayoutmode = $('input[name="' + this.ident + 'reportlayoutmode"]:checked').val()
	var resultsElement = $('#' + this.ident + "_div .record_container").get(0);
	if (typeof resultsElement !== 'undefined') {
		// Reset the result block if freshly loading
		if(reset) {
			$('#' + this.ident + "_div .record_container").removeClass('narrowmode');
			$('#' + this.ident + "_div .record_container").hide().show(0); // Force safari to redraw
			this.resultmode = 'normal';
		}

		// Note in the remainder of this code we are updating all record_container class
		// elements (including MCLF selection area) - however we still rely on the
		// results element for detection.
		if( this.reportlayoutmode == 'narrow' ) {
			$('#' + this.ident + "_div .record_container").addClass('narrowmode');
			this.resultmode = 'narrowmode';
		}
		else if( this.reportlayoutmode == 'normal' ) {
			$('#' + this.ident + "_div .record_container").removeClass('narrowmode');
			this.resultmode = 'normal';
		}
		else 
		{
			// Check if there is overflow to deal with - there seems to be a bit of variation in 
			// clientWidth/scrollWidth - resulting in adding 10px to cover it
			if(resultsElement.scrollWidth > ( resultsElement.clientWidth + 10) ) {
				$('#' + this.ident + "_div .record_container").addClass('narrowmode');
				this.resultmode = 'narrow';
			}
			else
			{
				$('#' + this.ident + "_div .record_container").removeClass('narrowmode');
				this.resultmode = 'normal';
			}
			this.resultsize = resultsElement.scrollWidth;
		}
	}	
	if(this.resultmode != resultModeBefore) {
		// Nothing records this change server side currently.

		// Resize the block
		if(this.block_id) {
			var block = Zymonic.lookup_object("Block", this.block_id);
			if(block) {
				block.autolength();
			}
		}
	}
}

// called when form is reloaded to reset and handlers on new elements
Zymonic.Form.Form.prototype.resetHandlers = function() {
	if (this.prefill_details) {
		this.setupPreFill(this.prefill_details);
	}
	if (this.sortable) {
		// function to autoscroll the screen if dragging near edge
		// needs to be custom function as built in scroll functionality
		// doesn't work nicely due to how desktop mode positioning works
		var sortable_autoscroll = function(event) {
			// is there a better way to get these magic numbers?
			// currently just hardcoded on what felt nice 
			if (event.clientY < 150) {
				window.scrollBy({
					top: -40,
					left: 0,
					behavior: "smooth",
				});
			} else if (event.clientY > ( window.innerHeight - 30 - $(event.target).height() ) ) {
				window.scrollBy({
					top: 40,
					left: 0,
					behavior: "smooth",
				});
			}
		};
		
		var form = this;
		this.getContainerDiv(" .HorizontalFormTable").sortable({
			items: '.record',
			containment: 'parent',
			cursor: 'move',
			
			// disable scrolling, doesn't work in desktop mode
			// uses a custom autoscroll 
			scroll: false,
			
			start: function(event, ui) {
				$(ui.item).addClass("ZymonicFormRecordBeingSorted");
				document.addEventListener("mousemove", sortable_autoscroll);
			},
			stop: function(event, ui) {
				$(ui.item).removeClass("ZymonicFormRecordBeingSorted");
				document.removeEventListener("mousemove", sortable_autoscroll);
			},
			update: function(event, ui) {
				if (form.sortable_field_zname) {
					// get onscreen order and update field
					var sequence = 1;
					$(ui.item).parent().children(".record").each(function(i, record_el) {
						var record_ident = $(record_el).attr('id');
						var field = form.getRecordField(record_ident, form.sortable_field_zname);
						if (field) {
							// set the value, and force it to be flaged as changed
							// so its always sent back to the server
							field.setValue(sequence);
							field.setValueAsChanged(sequence, false, true);
							sequence++;
						}
					});
				}
			},
		});
	}
};


// get form container or contents within
Zymonic.Form.Form.prototype.getContainerDiv = function(extra) {
	extra = extra || "";
	return $("#"+this.ident+"_div"+extra);
};

// register the form formats for this form
// nothing is current doing with this, but i think it makes sense to store them
Zymonic.Form.Form.prototype.addFormFormat = function(form_format) {
	if (!this.form_formats) {
		this.form_formats = [];
	}
	
	this.form_formats.push(form_format);
};

// get form records
Zymonic.Form.Form.prototype.getRecords = function(lookup_fields, lookup_record_containers) {
	
	// take copy of records
	var records = ( this.records ? this.records.slice() : [] );
	
	// lookup fields and/or containers
	if (lookup_fields || lookup_record_containers) {
		for (var i=0; i<records.length; ++i) {
			if (lookup_fields) {
				records[i].fields = getZymonicFieldsInRecord(records[i].record_ident);
			}
			if (lookup_record_containers) {
				records[i].container = this.getSingleRecordContainerDiv(records[i].record_ident);
			}
		}
	}
	
	return records;
};


// get form container of all records from the GUI or contents within
Zymonic.Form.Form.prototype.getAllRecordsContainerDiv = function(extra) {
	extra = extra || "";
	return this.getContainerDiv(" .record_container"+extra);
};

// get form record container from the GUI
Zymonic.Form.Form.prototype.getSingleRecordContainerDiv = function(record_id) {
	return this.getAllRecordsContainerDiv(" #"+record_id);
};

Zymonic.Form.Form.prototype.isHorizontal = function() {
	return this.horizontal;
};

Zymonic.Form.Form.prototype.getHorizontalTable = function() {
	if (!this.isHorizontal()) {
		return null;
	}
	
	if (!this.horizontal_table) {
		this.horizontal_table = this.getAllRecordsContainerDiv(" .HorizontalFormTable");
	}

	return this.horizontal_table;
};

// locks the record container and returns function to call to unblock it
Zymonic.Form.Form.prototype.blockRecord = function(record) {
	return Zymonic.Utils.block_gui_element( this.getSingleRecordContainerDiv(record.record_ident) );
};

// locks the record container and returns function to call to unblock it
Zymonic.Form.Form.prototype.blockAllRecords = function() {
	return loading_gui_element(this.getAllRecordsContainerDiv(), 'jquery_obj');
};

// function to clear any caches
Zymonic.Form.Form.prototype.clearCaches = function() {
	this.horizontal_table = null;
};

//returns the UI tabs tied to a form
Zymonic.Form.Form.prototype.getUITabs = function(recordIdent) {
	return $('#' + recordIdent).tabs();
}

//allows to user to navigate to next/prev UI tab when tabbing/backwards-tabbing off last/first field
Zymonic.Form.Form.prototype.nextFieldGroup = function(recordIdent){
	var tabObj = this.getUITabs(recordIdent);
	var currentTab = tabObj.find("li.ui-tabs-selected").index();
	var tabCount = tabObj.find(".ui-tabs-nav:visible").children().length; //may inadvertently grab children
	if(currentTab<tabCount){
		currentTab += 1;
		tabObj.tabs('select', currentTab);
		
		// find record so we can then find fieldgroup within and finally the first field to focus
		var record;
		if (this.records && this.records.length == 1) {
			record = this.records[0]; 
		} else {
			for (var i=0; i<this.records.length; ++i) {
				if (this.records[i].record_ident == recordIdent) {
					record = this.records[i];
					break;
				}
			}
		}
		if (record) {
			var field_group_ident = tabObj.find("li.ui-tabs-selected").attr('ident');
			if (record.field_groups && record.field_groups[field_group_ident] && record.field_groups[field_group_ident].first_field_ident) {
				var field = getZymonicField(record.field_groups[field_group_ident].first_field_ident);
				if (field) {
					field.input_elements().first().focus();
				}
			}
		}
	}	
}

Zymonic.Form.Form.prototype.prevFieldGroup = function(recordIdent){
	var tabObj = this.getUITabs(recordIdent);
	var currentTab = tabObj.find("li.ui-tabs-selected").index();
	if(currentTab>0){
		currentTab -= 1;
		tabObj.tabs('select', currentTab);
		
		// find record so we can then find fieldgroup within and finally the first field to focus
		var record;
		if (this.records && this.records.length == 1) {
			record = this.records[0]; 
		} else {
			for (var i=0; i<this.records.length; ++i) {
				if (this.records[i].record_ident == recordIdent) {
					record = this.records[i];
					break;
				}
			}
		}
		if (record) {
			var field_group_ident = tabObj.find("li.ui-tabs-selected").attr('ident');
			if (record.field_groups && record.field_groups[field_group_ident] && record.field_groups[field_group_ident].last_field_ident) {
				var field = getZymonicField(record.field_groups[field_group_ident].last_field_ident);
				if (field) {
					field.input_elements().last().focus();
				}
			}
		}
	}
}

Zymonic.Form.Form.prototype.loadFieldGroup = function(recordIdent, fieldgroupIdent, blockID, pageID){
	
	if (this.field_groups[fieldgroupIdent] && this.field_groups[fieldgroupIdent].loaded) { return; }
	this.field_groups[fieldgroupIdent] = {};
	var this_group = this.field_groups[fieldgroupIdent];
	
	// we need to set these now for success_cb to use for creating the xml document
	var form_ident = this.ident;
	var process_id = this.process_id;

	var form = this;
	var filter = this.getParentFilter(this.parent_filter_ident);
	var unblock = this.blockFieldGroup(fieldgroupIdent);
	var record_id = this.getRecord(recordIdent).id;
	var record_id_str = "";
	if (record_id) {
		for (var field in record_id) {
			record_id_str += field + "=" + record_id[field] + "|";
		}
		record_id_str = record_id_str.slice(0,-1);
	}
	// variables to match Form getparam - used for cg_set
	var blockID_pattern = blockID + "_";
	var fieldgroup_id_no_process_name = fieldgroupIdent.substring(fieldgroupIdent.indexOf(this.zname));
	if(!filter) { fieldgroup_id_no_process_name = this.ident + fieldgroup_id_no_process_name; }
	
	var record_id_no_process_name = recordIdent.substring(recordIdent.indexOf(this.zname)).replace(blockID_pattern, "");
	
	var success_cb = function(xml) {
					// get the xml for this fieldgroup in the form of a document and transform it
					var xml_doc = form.createFieldGroupDocument($(xml), fieldgroupIdent, pageID, 
							blockID, process_id, form_ident);
					var zt = new Zymonic.Transformer.Transformer();
					zt.init({ blockxml: xml_doc});
					// add it to the fieldgroups data div
					$('#' + fieldgroupIdent+"_inner_div").html(zt.resultDocument);
					// run any JS needed
					Zymonic.Utils.reRunJS($('#' + fieldgroupIdent+"_inner_div"));
					// flag the fieldgroup as loaded
					this_group.loaded = true;
					$("#"+fieldgroupIdent+"_menuitem").removeClass("FieldGroupNotLoaded");
					// if we're loading a filter group, bind change handlers to search fields
					if (filter) filter.bindSearchFields();
					// unblock the GUI
					unblock();
					}

	var error_cb = function(xhr, type, error) {
				     // Removed the unblock here - see Filter.js line 359:
		             // we don't unblock on abort as requests are aborted by 
		             // duplicate requests, so let that newer request do the unblocking
		             //unblock();
				     if (console && console.error) {
						 console.error("Error loading field group"+fieldgroupIdent+":"+type+" - "+error);
				     }
				   }
	
	var request_key = "loading_" + fieldgroupIdent;
	
	var fData = Zymonic.new_form_data();
	if(this.reportlayoutmode) 
	fData.append(this.ident + 'reportlayoutmode', this.reportlayoutmode);
	fData.append("ZZFblock_id",blockID);
	fData.append("ZZno_display_attributes",'false');
	fData.append("ZZFfield_group_id",fieldgroupIdent);
	fData.append("ZZforce_single_field_group",fieldgroupIdent);
	fData.append("ZZFparent_fap_from_block","true");
	fData.append("ZZFpage_id",pageID);
	if (filter) {
		fData.append("ZZwebservicemode","filter");
		fData.append("ZZBzname",filter.zname);
		fData.append("ZZFignore_not_in_field_group","true");
		fData.append("ZZFident",filter.ident);
		fData.append(filter.ident+"skip_results","true");
		fData.append("current_fieldgroup",fieldgroupIdent);
	}
	else {
		fData.append("ZZwebservicemode","form");
		fData.append("ZZBzname",this.zname);
		if (record_id_str) { fData.append("ZZFrec_id",record_id_str); }
		fData.append("ZZBprocess_id",this.process_id); 
		fData.append(recordIdent + "current_fieldgroup",fieldgroupIdent);
		fData.append("ZZFident",this.ident);
	}

	// although this can happen in a filter's search fields 
	// we treat it as a process type as it can change data
	Zymonic.request("POST", fData, true, request_key, Zymonic.ajax_request_type.PROCESS, success_cb, error_cb,
	                null, function() { form.blockFieldGroup(fieldgroupIdent) } ); 
}

Zymonic.Form.Form.prototype.setFieldGroupLoaded = function(fieldgroupIdent){
	
	// Prevents a duplicate call 
	if (fieldgroupIdent == this.records[0].record_ident) { return; }
	
	this.field_groups[fieldgroupIdent] = {};
	this.field_groups[fieldgroupIdent].loaded = true;
	$("#"+fieldgroupIdent+"_menuitem").removeClass("FieldGroupNotLoaded");
}

Zymonic.Form.Form.prototype.clearFieldGroupCaches = function(){
	// if it's a subform there's no need to remove flags as fgs will still be loaded
	if(this.isSubForm()) return;
	this.field_groups = {};
}

Zymonic.Form.Form.prototype.isSubForm = function() {
	if(this.parent_field && this.parent_field.getClass() == 'SubForm') {
		return true;
	}
	else
	{
		return false;
	}
}

Zymonic.Form.Form.prototype.blockFieldGroup = function(fieldgroupIdent){
	return loading_gui_element(fieldgroupIdent+"_inner_div");
}

// add a record to this form
Zymonic.Form.Form.prototype.addRecord = function(record) {
	// if record exists, overwrite it
	for (var i = 0; i < this.records.length; i++) {
		if (this.records[i].record_ident == record.record_ident) {
			this.records[i] = record;
			return;
		}
	}
	
	// add to list if it doesn't exists
	this.records.push(record);
	
	// trigger events for records changing
	this.triggerRecordsChanged();
};

// remove a record from this form
Zymonic.Form.Form.prototype.removeRecord = function(record) {
	// if record exists, remove it
	var removed = false;
	for (var i = 0; i < this.records.length; i++) {
		if (this.records[i].record_ident == record.record_ident) {
			this.records.splice(i,1);
			removed = true;
		}
	}
	
	// trigger events for records changing
	if (removed) {
		this.triggerRecordsChanged({ recalculation_needed: true });
	}
};

Zymonic.Form.Form.prototype.getRecord = function(recordIdent, lookup_fields){
	for (var i = 0; i < this.records.length; i++) {
		if (this.records[i].record_ident == recordIdent){
			if (lookup_fields) {
				this.records[i].fields = getZymonicFieldsInRecord(this.records[i].record_ident);
			}
			return this.records[i];
		}
	}
}
Zymonic.Form.Form.prototype.getRecordField = function(recordIdent, field_zname){
	var record = this.getRecord(recordIdent, true);
	if (!record) {
		return null;
	}
	
	for (var i=0; i<record.fields.length; ++i) {
		if (record.fields[i].zname == field_zname) {
			return record.fields[i];
		}
	}
	
	return null;
		
}
Zymonic.Form.Form.prototype.getPlaceholderRecords = function(lookup_fields, lookup_record_containers) {
	var records = this.getRecords(lookup_fields, lookup_record_containers);
	var placeholders = [];
	for (var i = 0; i < records.length; i++) {
		if (records[i].is_placeholder){
			placeholders.push(records[i]);
		}
	}
	return placeholders;
}

// clears all records on this form
Zymonic.Form.Form.prototype.clearRecords = function() {
	this.records = [];
};

// fetches the current fieldgroup for the given record
Zymonic.Form.Form.prototype.getCurrentFieldGroup = function(record){
	return $("#"+record.record_ident+"current_fieldgroup").val();
}

Zymonic.Form.Form.prototype.getParentFilter = function(parent_filter_ident){
	if (parent_filter_ident) { return getZymonicFilter(parent_filter_ident); }
}

Zymonic.Form.Form.prototype.createFieldGroupDocument = function(xml, field_group_ident, page_id, block_id, process_id, form_ident){
	
	// grab just the fieldgroup we're loading, and check for subforms inside it
	var field_group_xml = xml.find("[ident='" + field_group_ident + "']");
	var sub_forms = field_group_xml.find("[type='Form']");
	var parent_form_zname = xml.find("[type='Form']")[0].nodeName;
	var sub_form_ident;
	var sub_form_name;

	// attributes needed to set up fields via xslt in ZymonicFieldUtils
	xml.find("[type='Field']").each(function(i, field) {
		$(field).attr({"page_id": page_id, "block_id": block_id, "process_id": process_id,  "form_ident": form_ident, 
			"horizontal": 'false' });
		if ( parent_form_zname != 'search_fields' ) { $(field).attr("form_zname", parent_form_zname); }
	});
	
	// if there are subform(s), then the subform fields have a different parent_form
	if(sub_forms){
		sub_forms.each(function(i, sub_form) {
			sub_form_name = sub_form.nodeName;
			sub_form_ident = $(sub_form).attr("ident");
			$(sub_form).find("[type='Field']").each(function(i, field) {
				$(field).attr('form_ident', sub_form_ident);
				$(field).attr('form_zname', sub_form_name);
			});
		});
	}

	// will also need a filter 'wrapper', navigation and record node for transformation
	var filter_node = xml.find("[type='Filter']");
	
	// record contains all fieldgroups so we have to empty it and then later append the one we're loading
	var record = xml.find("record").first().clone().empty();
	var navigation_node = xml.find("navigation").get(0);

	// NOTE - Using XMLSerializer as IE doesn't seem to support .outerHTML for xml elements...
	// think we only need <navigation> if it's a process, so if it doesn't exist just set it as an empty string
	navigation_node = (navigation_node ? (navigation_node.outerHTML || 
			(new XMLSerializer().serializeToString(navigation_node))) : '');
	
	// working transformation consists of - Filter > Record > Fieldgroup, so assemble the string as such
	record.append(field_group_xml.get(0));
	record = record.get(0).outerHTML || (new XMLSerializer().serializeToString(record.get(0)));
	var xml_string = '<Zymonic AJAXSupport="true" type="Filter" ident="' + filter_node.attr("ident") + 
		'" UserFieldOrdering="' + filter_node.attr("UserFieldOrdering") + '">';
	xml_string += record + '</Zymonic>';
	
	// for some reason parseXML does not allow = in attributes
	// so try setting it directly after parsing
	var parsed_xml = jQuery.parseXML(xml_string);
	$(parsed_xml).find("Zymonic").attr("pageurl", xml.find("Zymonic").attr("pageurl"));
	
	return parsed_xml;
}

Zymonic.Form.Form.prototype.getPage = function() {
	return $('#' + this.ident + 'go_to_page').val();
};

Zymonic.Form.Form.prototype.getRecordsPerPage = function() {
	return $('#' + this.ident + 'records_per_page').val();
};

Zymonic.Form.Form.prototype.appendNavigationToForm = function(form_data) {
	
	// add page and records per page
	var page = this.getPage();
	var records_per_page = this.getRecordsPerPage();
	if (page) {
		form_data.append( this.ident+"go_to_page", page );
	}
	if (records_per_page) {
		form_data.append( this.ident+"records_per_page", records_per_page );
	}
};

// callback to run when records change
Zymonic.Form.Form.prototype.onRecordsChange = function(cb, caller_ident) {
	Zymonic.Utils.attach_event(
		$(this),
		'records_changed_'+this.ident,
		'records_changed_'+this.ident+(caller_ident ? caller_ident : ""),
		cb
	);
};

// trigger callback to run when records change
Zymonic.Form.Form.prototype.triggerRecordsChanged = function(extras) {
	Zymonic.Utils.trigger_event(
		$(this),
		'records_changed_'+this.ident,
		null,
		[ this, extras ]
	);
	
	// Resize the block
	if(this.block_id && Zymonic.lookup_object("Block", this.block_id)) {
   	  Zymonic.lookup_object("Block", this.block_id).autolength();
    }
};

// sets up everything needs to run prefill via JS
Zymonic.Form.Form.prototype.setupPreFill = function(prefill_details) {
	// find the button in the GUI and add handler, for each record
	var form = this;
	Zymonic.Utils.attach_event(
		this.getPreFillButton(),
		"click",
		this.ident+"prefill",
		function(event) {
			form.runPreFill.call(form,  prefill_details);
	
			// prevent the normal click action
			event.preventDefault();
		}
	);
};


// get the prefill button, if present
Zymonic.Form.Form.prototype.getPreFillButton = function() {
	return $("#"+this.ident+"prefill");
};

// runs the prefill on the current form
Zymonic.Form.Form.prototype.runPreFill = function(prefill_details) {
	
	// disable the GUI side temporarily
	if (false) {
		
	// load up the filter
	var source_filter ;
	if ( prefill_details.source_filter_class && Zymonic.Filter[prefill_details.source_filter_class] ) {
		source_filter = new Zymonic.Filter[prefill_details.source_filter_class]();
	} else {
		source_filter = new Zymonic.Filter.Filter();
	}
	source_filter.init({
		zname: prefill_details.source_filter_zname, 
		ident: this.ident+"_"+prefill_details.source_filter_zname,
		
		// TODO: restrict fields to those needed for the prefill
	});
	
	// set params for the search fields
	for (var i=0; i<prefill_details.linking_field_maps.length; ++i) {
		var field = getZymonicField(prefill_details.linking_field_maps[i].source_field_ident);
		if (field) {
			source_filter.addExtraParam(source_filter.ident+prefill_details.linking_field_maps[i].destination_field, field.getValue());
		}
	}
	
	// get the results
	var form = this;
	var source_filter_results = source_filter.getFilterData(
		Zymonic.new_form_data(),
		function(xml) {
			// grab all the results
			var results = [];
			$(xml).find(prefill_details.source_filter_zname+" > report > result").each(function(i, xml_result) {
				// result id and ident
				var result = { ident : $(xml_result).attr('ident'), id: {} };
				$.each($(xml_result).find("ZZid").get(0).attributes, function(i, attribute) {
					result.id[attribute.name] = attribute.value;
				});
				
				// fields in result				
				$(xml_result).find("*[type='Field']").each(function(i, xml_field) {
					result[xml_field.tagName] = $(xml_field).find("Value").text();
				});
				
				results.push(result);
			});
			
			// synchronize results
			form.synchronizeRecords(
				results,
				prefill_details.pre_fill_field_maps,
				'UpdateOrInsert',
				true
			);
			
			// all done
			unblock();
		},
		null, null, null,
		function() { Zymonic.Utils.block_gui_element( form.getContainerDiv() ) }
	);
	return;
	}
	
	// block the GUI
	var unblock = Zymonic.Utils.block_gui_element( this.getContainerDiv() );
	
	// otherwise reload just this form
	var form_data = Zymonic.new_form_data();
	
	// as all this forms record data to form only
	this.appendRecordsDataToForm(form_data);
	
	// add dependent fields from linking field maps and parent form id field maps as extra fields
	var extra_fields = [];
	for (var i=0; i<prefill_details.linking_field_maps.length; ++i) {
		var field = getZymonicField(prefill_details.linking_field_maps[i].source_field_ident);
		if (field) {
			field.appendToForm(form_data);
			form_data.append("ZZFextra_field_"+field.zname+'_ident', field.ident);
			extra_fields.push(field.zname);
		}
	}
	var parent_field = this.getParentField();
	if (parent_field && parent_field.parent_form_id_field_maps) {
		for (var i=0; i<parent_field.parent_form_id_field_maps.length; ++i) {
			var field = getZymonicField(parent_field.parent_form_id_field_maps[i].source_field_ident);
			if (field) {
				field.appendToForm(form_data);
				form_data.append("ZZFextra_field_"+field.zname+'_ident', field.ident);
				extra_fields.push(field.zname);
			}
		}
		form_data.append("ZZFparent_field", parent_field.zname);
	}
	form_data.append('ZZFextra_fields', extra_fields.join(","));
	
	// rest of the details to trigger the reload
	if(this.reportlayoutmode) 
	fData.append(this.ident + 'reportlayoutmode', this.reportlayoutmode);
	form_data.append("ZZwebservicemode", "form");
	form_data.append("ZZno_display_attributes", "false");
	form_data.append("ZZBzname", this.zname);
	form_data.append("ZZFpage_id", this.page_id);
	form_data.append("ZZFblock_id", this.block_id);
	form_data.append("ZZBprocess_id", this.process_id); 
	form_data.append("ZZFident", this.ident);
	form_data.append("ZZFparent_fap_from_block", "true");
	form_data.append("ZZFforce_presave", "true");

	var form = this;
	Zymonic.request(
		"POST", form_data, true, "running_prefill_"+this.ident, Zymonic.ajax_request_type.PROCESS,
		function(xml) {
			form.replaceWithTransformedXML(xml);
			unblock();
		},
		function(xhr, type, error) {
			Zymonic.log_error("Error running prefill for form "+this.ident+":"+type+" - "+error);
		},
		null,
		function() { Zymonic.Utils.block_gui_element( form.getContainerDiv() ); }
	); 
};

// runs the prefill on the current form
Zymonic.Form.Form.prototype.replaceWithTransformedXML = function(xml) {
	// transform the xml and run js on it setup objects, e.g. to add any new records to form object
	var full_html_result = Zymonic.Utils.transformXML(xml);
	
	// for some reason need to look in children, looking at top level doesn't work
	var full_html = $(full_html_result).children();
	
	// replace all the record
	// for some reason the replace with call does not add script tags to the page
	// so we send through the force flag to ensure scripts are run
	// this makes debugging harder, but its more of a reason to take script tags
	// out of the XSL/HTML and into Js objects
	this.getContainerDiv().replaceWith(full_html);
	Zymonic.Utils.reRunJS(full_html, true);
	
	// explicitly trigger the records changes action on the form
	this.triggerRecordsChanged();
	
	this.clearCaches();
};

// Append to form data
Zymonic.Form.Form.prototype.appendRecordsDataToForm = function(form_data) {
	
	var records = this.getRecords(true);
	for (var i=0; i<records.length; ++i) {
		this.appendRecordDataToForm(form_data, records[i]);
	}
};

//Append to form data
Zymonic.Form.Form.prototype.appendRecordDataToForm = function(form_data, record, cb) {
	
	for (var i=0; i<record.fields.length; ++i) {
		record.fields[i].appendToForm(form_data);
		if (cb) {
			cb(record, record.fields[i]);
		}
	}
};

// gets parent field for this form, if there is one
Zymonic.Form.Form.prototype.getParentField = function() {
	if (this.parent_field) {
		return this.parent_field;
	}
	
	if (this.parent_field_ident) {
		this.parent_field = getZymonicField(this.parent_field_ident);
	}
	
	return this.parent_field;
};

// synchronize incoming records with this form's records
// this is essentially a copy of Zymonic::Table::synchronize_records so has functionality not current in use
Zymonic.Form.Form.prototype.synchronizeRecords = function(records, field_maps, update_type, delete_others) {
	if (!Zymonic.Form.Form.prototype.SYNC_UPDATE_TYPES[update_type]) {
		Zymonic.log_error("Invalid update type: "+update_type);
		return;
	}
	
	// ignore any placeholders and check record conditions
	var new_records = [];
	for (var i=0; i<records.length; ++i) {
		if ( !( records[i].is_placeholder || ( records[i].autocreated && records[i].autocreated == -1 ) ) ) {
			if (!this.synchronize_record_conditions || this.synchronizeRecordShouldBeProcessed(records[i])) {
				new_records.push(records[i]);
			}
		} 
	}
	records = new_records;
	
	// nothing to do if no records to synchronize, and we don't have to delete others
	if ( records.length == 0 && !delete_others) {
		return {
			added: [],
			updated: [],
			deleted: [],
			synchronized: [],
		};
	}
	
	// do we need to delete anything
	if (Zymonic.Form.Form.prototype.SYNC_UPDATE_TYPES_TO_DELETE_BEFORE_SYNC[update_type] && delete_others) {
		// not currently in use
		// TODO: flag all existing records to delete
	}
	
	// get the records to synchronize
	var records_to_synchronize = [];
	for (var i=0; i<records.length; ++i) {
		var synchronized_records = this.synchronizeRecord(records[i], field_maps, update_type);
		records_to_synchronize = records_to_synchronize.concat(synchronized_records);
	}
	
	// TODO: sync all those records
	var result = {
		added: [],
		updated: [],
		deleted: [],
		synchronized: [],
	};

	for (var i=0; i<records_to_synchronize.length; ++i) {
		result.synchronized.push(records_to_synchronize[i]);
		if (records_to_synchronize[i].sync_to_delete) {
			result.deleted.push(records_to_synchronize[i]);
		} else if (records_to_synchronize[i].is_placeholder) {
			result.added.push(records_to_synchronize[i]);
		} else {
			result.updated.push(records_to_synchronize[i]);
		}
	}
	
	// TODO: need a way to add these records changes to this form such that
	// a) they get shown on screen and are usable as normal form records are, and
	// b) appendToForm adds all the params to add, update and delete the records as appropriate
	
	return result;
};

// not actually used currently, added for completeness, hence no check
Zymonic.Form.Form.prototype.synchronizeRecordShouldBeProcessed = function(record) {
	return true;
};

// synchronize the incoming record
// this is essentially a copy of Zymonic::Table::synchronize_record so has functionality not current in use
Zymonic.Form.Form.prototype.synchronizeRecord = function(record, field_maps, update_type) {
	
	var matching_records = [];
	if (Zymonic.Form.Form.prototype.SYNC_UPDATE_TYPES_TO_ADD_RECORDS[update_type]) {
		matching_records.push(this.setupPlaceholder());
	} else if (Zymonic.Form.Form.prototype.SYNC_UPDATE_TYPES_TO_LOOKUP_RECORDS[update_type]) {
		var record_key = this.synchronizeRecordKey(record, field_maps);
		var found_records = this.findRecords(record_key);
		if (found_records.length > 0) {
			matching_records = matching_records.concat(found_records);
		} else if (Zymonic.Form.Form.prototype.SYNC_UPDATE_TYPES_TO_ADD_RECORD_IF_NOT_FOUND[update_type]) {
			matching_records.push(this.setupPlaceholder());
		} else if (Zymonic.Form.Form.prototype.SYNC_UPDATE_TYPES_TO_SKIP_RECORD_IF_FOUND[update_type]) {
			return [];
		}
	}
	
	if (matching_records.length > 0 && !this.synchronize_multiple_records) {
		// currently not in user
		// TODO: resolve multiple records if needed
	}
	
	// if we are going to delete these records can return them now without any field updates
	if (Zymonic.Form.Form.prototype.SYNC_UPDATE_TYPES_TO_DELETE_RECORDS[update_type]) {
		return matching_records;
	}
	
	// grab the update field maps
	var update_field_maps = [];
	for (var i=0; i<field_maps.length; ++i) {
		if (field_maps[i].overwrite) {
			update_field_maps.push(field_maps[i]);
		}
	}
	
	// set fields for matched records
	var updated_records = [];
	for (var i=0; i<matching_records.length; ++i) {
		var updated_record = this.synchronizeFields(
			record,
			matching_records[i],
			( matching_records[i].is_placeholder ? field_maps : update_field_maps )
		);
		
		// if flag set, lookup non-keyfields to check if there is data on them
		if (updated_record.is_placeholder) {
			if ( !this.only_add_on_non_keyfield_data || updated_record.fields_changed.length > 0 ) {
				updated_records.push(updated_record);
			}
		} else {
			// NOTE: server side there are checks on zzlu for last updates
			// these have been left out here as we don't have DB access to check last updated values easily
			updated_records.push(updated_record);
		}
	}
	
	return updated_records;
};

// assemble record key using field maps
// this is essentially a copy of Zymonic::Table::synchronize_record_key so has functionality not current in use
Zymonic.Form.Form.prototype.synchronizeRecordKey = function(record, field_maps) {
	var lookup_key = {};
	for (var i=0; i<field_maps.length; ++i) {
		if (field_maps[i].key) {
			lookup_key[field_maps[i].destination_field] = this.synchronizeSourceFieldValue(field_maps[i].source_field, record);
		}
	}
	
	return lookup_key;
};

//assemble record key using field maps
//this is essentially a copy of Zymonic::Table::synchronize_source_field_value so has functionality not current in use
Zymonic.Form.Form.prototype.synchronizeSourceFieldValue = function(field, record) {
	
	// check if field is in the record
	if (record[field]) {
		return record[field];
	} else {
		// TODO: if not then need to check on the form itself
		return null;
	}
};

// finds records in thsi form which match the incoming search fields
Zymonic.Form.Form.prototype.findRecords = function(search) {
	var matches;
	var matches_needed = Object.keys(search).length;
	var records = this.getRecords(true);
	var records_found = [];
	for (var i=0; i<records.length; ++i) {
		matches = 0;
		for (var j=0; j<records[i].fields.length; ++j) {
			var field = records[i].fields[j];
			if (search[field.zname]) {
				var field_value = field.getValue();
				var search_value = search[field.zname];
				if (field_value == search_value) {
					++matches;
				} else {
					// missing match so can stop early
					break;
				}
			}
		}
		if (matches == matches_needed) {
			records_found.push(records[i]);
		}
	}
	
	return records_found;
};

// update fields on the record from field maps
// this is essentially a copy of Zymonic::Table::synchronize_fields so has functionality not current in use
Zymonic.Form.Form.prototype.synchronizeFields = function(source_record, record, field_maps) {
	// TODO: set values from source on record using field maps
	return record;
};

// creates a new record on the form
Zymonic.Form.Form.prototype.setupPlaceholder = function(placeholder_record_to_copy, avoid_ident_conflicts) {
	
	if (!placeholder_record_to_copy) {
		placeholder_record_to_copy = this.getContainerDiv().find(".ZymonicJSPlaceholderRecord:not(.ZymonicBlockLoading)");
	}
	if (placeholder_record_to_copy.length != 1) {
		Zymonic.log_error("Unable to find placeholder record");
		return;
	}
	
	// clone the original placeholder record
	var placeholder_record_html = placeholder_record_to_copy.clone(true, true);
	
	// strip any block loading
	placeholder_record_html.find(".blockUI").detach();
	
	// clear all field values
	placeholder_record_html.find(":input").val('');
	
	// if flags set then change idents on all inputs to avoid conflicts with the new copy
	if (avoid_ident_conflicts) {
		placeholder_record_to_copy.attr( 'id', placeholder_record_to_copy.attr('id') + '_loading_' + (Date.now()/1000) );
		placeholder_record_to_copy.find(":input").each(function(i,el) { $(el).attr('id', $(el).attr('id') + '_loading_' + (Date.now()/1000) ); });
	}
	
	// add to screen
	if (this.horizontal) {
		this.getHorizontalTable().append(placeholder_record_html);
	} else {
		this.getAllRecordsContainerDiv().append(placeholder_record_html);
	}
	
		// trigger the handlers
		this.triggerRecordsChanged(	);
};

// whether this form allows adding
Zymonic.Form.Form.prototype.canAddRecords = function() {
	if (this.no_add) {
		return false;
	}
	return true;
};

// get the add button for a specific record
Zymonic.Form.Form.prototype.getAddButton = function(record_ident) {
	var container = this.getSingleRecordContainerDiv(record_ident);
	if (container) {
		return container.find(".ZymonicFormAddButton");
	}
	return null;
};

// adds the incoming field to the form record, if it exists
Zymonic.Form.Form.prototype.addFieldToRecord = function(record_ident, field) {
	var record = this.getRecord(record_ident);
	if (record) {
		if (!record.field_lookup) {
			record.field_lookup = {};
		}
		record.field_lookup[field.zname] = field;
	}
};

// initilializes a set multiple field on this form
Zymonic.Form.Form.prototype.initSetMultipleField = function(field_zname, field_ident, display_name, short_description) {
	// duplicate the field
	var new_ident = this.duplicateField('.ZymonicFieldSetMultiple', field_ident, '_zz_set_multiple_field', display_name, short_description);
	
	// js handling when it changes
	var form = this;
	Zymonic.Utils.attach_event(
		$("#"+new_ident+"_div :input"),
		"change", new_ident,
		function() {
			var value;
			if ($(this).is(":checkbox")) {
				if ($(this).is(":checked")) {
					value = $(this).val();
				}
			} else {
				value = $(this).val();
			}
			
			// get all records and fields
			var records = form.getRecords(true);
			for (var i=0; i<records.length; ++i) {
				for (var j=0; j<records[i].fields.length; ++j) {
					var field = records[i].fields[j];
					if (field.zname == field_zname) {
						records[i].fields[j].setValue(value);
						break;
					}
				}
			}
			
		}
	);
};

// function to duplicate a field on the form and returns its new ident
Zymonic.Form.Form.prototype.duplicateField = function(search, field_ident, new_ident_suffix, display_name, short_description) {
	// find the field and change idents and values
	var field_container = $(search+" .ZymonicField#"+field_ident+"_div");
	var html = field_container.prop('outerHTML');
	
	// change idents
	var new_ident = field_ident + new_ident_suffix;
	var new_html = html.replace( new RegExp( field_ident, "g"), new_ident );
	
	// replace it
	field_container.prop('outerHTML', new_html);
	
	// set class so its not treated as an unsaved change
	$(search+" .ZymonicField#"+new_ident+"_div").addClass("ZymonicIgnoreAsUnsavedChange");
	
	// set labels (add it if not there)
	var new_label = "<span class='FieldLabelSpan'>"+display_name+"<div class='FieldShortDescription'>"+short_description+"</div></span>";
	var field_label = $(search+" .ZymonicField#"+new_ident+"_div label");
	if (field_label.find('FieldLabelSpan').length) {
		field_label.find('FieldLabelSpan').replaceWith(new_label);
	} else {
		field_label.append(new_label);
	}
	
	return new_ident
};

// function to create a new input field on the form and returns its new ident
Zymonic.Form.Form.prototype.newEmptyField = function(search, field_ident, new_ident_suffix, display_name, short_description) {
	// new ident idents
	var new_ident = field_ident + new_ident_suffix;
	
	// create a basic input field and container, set class so its not treated as an unsaved change
	var new_html = $("<div/>").attr("id", new_ident+"_div").addClass("ZymonicField ZymonicIgnoreAsUnsavedChange");
	$("<label/>").attr("id", new_ident+"_label").attr("for", new_ident).html("&nbsp;").appendTo(new_html);
	$("<input/>").attr("type", "text").attr("id", new_ident).attr("name", new_ident).val("").appendTo(new_html);
	
	// add new label if existing field needs it, e.g. horizontal forms don't need lavels
	var new_label = "<span class='FieldLabelSpan'>"+display_name+"<div class='FieldShortDescription'>"+short_description+"</div></span>";
	var field_label = $(search+" .ZymonicField#"+new_ident+"_div label");
	if (field_label.find('FieldLabelSpan').length == 0) {
		new_html.find("label").append(new_label);
	}
	
	// find the field and replace it
	var field_container = $(search+" .ZymonicField#"+field_ident+"_div");
	field_container.prop('outerHTML', new_html.prop('outerHTML'));
	
	return new_ident;
};


// initilializes a form search field on this form
Zymonic.Form.Form.prototype.initFormSearchField = function(field_zname, field_ident, form_search_condition, form_search_regex, display_name, short_description) {
	// duplicate the field
	var new_ident = this.newEmptyField('.ZymonicFieldFormSearch', field_ident, '_zz_form_search_field', display_name, short_description);
	
	// clear the field value
	var input = $("#"+new_ident+"_div :input");
	input.val('');
	
	// add to list
	this.form_search_fields.push({
		input_id: new_ident,
		field_zname: field_zname,
		form_search_condition: form_search_condition,
		form_search_regex: form_search_regex
	});
	
	// handler to search the form
	var form = this;
	function handler() { form.startFormSearch(); };
	
	// attach handler on change, TODO: also default handler for the field, e.g. keyup, blur, click, etc..
	Zymonic.Utils.attach_event( $("#"+new_ident+"_div :input"), "change", new_ident, handler );
	var field = getZymonicField(field_ident);
	if (field && field.defaultHandler) {
		Zymonic.Utils.attach_event( $("#"+new_ident+"_div :input"), field.defaultHandler, new_ident, handler );
	}
};

// function to search records
Zymonic.Form.Form.prototype.startFormSearch = function() {
	
	// build search from form search fields
	var search = {};
	var show_all = true;
	for (var i=0; i<this.form_search_fields.length; ++i) {
		var form_search_field = this.form_search_fields[i];
		var input = $("#"+form_search_field.input_id+":input");
		
		// get value
		var value;
		if ($(input).is(":checkbox")) {
			if ($(input).is(":checked")) {
				value = $(input).val();
			}
		} else {
			value = $(input).val();
		}
		
		if (value) {
			// if no values set then can show all, set to false on first value found
			show_all = false;
			
			// setup condition or regex for searching
			search[form_search_field.field_zname] = {};
			if (form_search_field.form_search_condition) {
				if (isNaN(value)) {
					value = '"'+value+'"';
				}
				search[form_search_field.field_zname].condition = form_search_field.form_search_condition.replaceAll("ZZFORMSEARCH", value);
			} else if (form_search_field.form_search_regex) {
				search[form_search_field.field_zname].regex = new RegExp(form_search_field.form_search_regex.replaceAll("ZZFORMSEARCH", value), "i");
			}
		}
	}
	
	if (show_all) {
		this.showAllRecords();
	} else {
		this.limitRecordsByFormSearch(search);
	}
};
Zymonic.Form.Form.prototype.limitRecordsByFormSearch = function(search) {
	
	// check each record
	var records = this.getRecords(true);
	for (var i=0; i<records.length; ++i) {
		// show record now, hide it later if any conditions fail
		this.showRecord(records[i].record_ident);
		var hide_record = false
		for (var j=0; j<records[i].fields.length; ++j) {
			var field = records[i].fields[j];
			if (field.zname in search) {
				var field_value = field.getValue(true);
				if (search[field.zname].condition) {
					var record_condition = search[field.zname].condition.replaceAll("ZZFIELD", field_value);
					if (! eval(record_condition) ) {
						hide_record = true;
						break;
					}
				} else if (search[field.zname].regex) {
					if (! field_value.match(search[field.zname].regex) ) {
						hide_record = true;
						break;
					}
				}
			}
		}
		
		if (hide_record) {
			this.hideRecord(records[i].record_ident);
		}
	}
};

// functions to hide/show form records
Zymonic.Form.Form.prototype.hideRecord = function(record_ident) {
	this.getSingleRecordContainerDiv(record_ident).hide();
};
Zymonic.Form.Form.prototype.showRecord = function(record_ident) {
	this.getSingleRecordContainerDiv(record_ident).show();
};
Zymonic.Form.Form.prototype.showAllRecords = function(record_ident) {
	this.getAllRecordsContainerDiv(" .record").show();
};

// checks for any unsaved changes on the fields in this form and highlights them
Zymonic.Form.Form.prototype.checkForUnsavedChanges = function() {
	
	var unsaved_changes = 0;
	
	var records = this.getRecords(true);
	for (var i=0; i<records.length; ++i) {
		for (var j=0; j<records[i].fields.length; ++j) {
			var field = records[i].fields[j];
			if (field.checkForUnsavedChanges()) {
				++unsaved_changes;
			}
		}
	}
	
	return unsaved_changes > 0;
};