');
+ var attachFields = [];
+ var attach = [];
+ var displayFields = {};
+ var tbody = dt.table(undefined).body();
+ for (var i = 0, ien = dt.columns(':visible').count(); i < ien; i++) {
+ var visIdx = dt.column(i + ':visible').index();
+ var td = $('| ').appendTo(tr);
+ var fields = _dtFieldsFromIdx(dt, this.s.fields, visIdx, true);
+ var settings = dt.settings()[0];
+ var className = settings.aoColumns[visIdx].sClass;
+ if (className) {
+ td.addClass(className);
+ }
+ if (Object.keys(fields).length) {
+ attachFields.push(Object.keys(fields));
+ attach.push(td[0]);
+ $.extend(displayFields, fields);
+ }
+ }
+ var append = function () {
+ // Remove the data empty message
+ if (dt.page.info().recordsDisplay === 0) {
+ $(tbody).empty();
+ }
+ var action = insertPoint === 'end'
+ ? 'appendTo'
+ : 'prependTo';
+ tr[action](tbody);
+ };
+ this.__dtFakeRow = tr;
+ // Insert into the table
+ append();
+ dt.on('draw.dte-createInline', function () {
+ append();
+ });
+ return {
+ 0: {
+ attach: attach,
+ attachFields: attachFields,
+ displayFields: displayFields,
+ fields: this.s.fields,
+ type: 'row'
+ }
+ };
+ },
+ fakeRowEnd: function () {
+ var dt = _dtApi(this.s.table);
+ dt.off('draw.dte-createInline');
+ this.__dtFakeRow.remove();
+ this.__dtFakeRow = null;
+ // Restore data empty row
+ if (dt.page.info().recordsDisplay === 0) {
+ dt.draw(false);
+ }
+ },
+ // get idSrc, fields to edit, data and node for each item
+ fields: function (identifier) {
+ var idFn = dataGet(this.s.idSrc);
+ var dt = _dtApi(this.s.table);
+ var fields = this.s.fields;
+ var out = {};
+ if ($.isPlainObject(identifier) &&
+ (identifier.rows !== undefined || identifier.columns !== undefined || identifier.cells !== undefined)) {
+ // Multi-item type selector
+ if (identifier.rows !== undefined) {
+ _dtRowSelector(out, dt, identifier.rows, fields, idFn);
+ }
+ if (identifier.columns !== undefined) {
+ _dtColumnSelector(out, dt, identifier.columns, fields, idFn);
+ }
+ if (identifier.cells !== undefined) {
+ _dtCellSelector(out, dt, identifier.cells, fields, idFn);
+ }
+ }
+ else {
+ // Just a rows selector
+ _dtRowSelector(out, dt, identifier, fields, idFn);
+ }
+ return out;
+ },
+ id: function (data) {
+ var idFn = dataGet(this.s.idSrc);
+ return idFn(data);
+ },
+ individual: function (identifier, fieldNames) {
+ var idFn = dataGet(this.s.idSrc);
+ var dt = _dtApi(this.s.table);
+ var fields = this.s.fields;
+ var out = {};
+ var forceFields;
+ if (fieldNames) {
+ if (!Array.isArray(fieldNames)) {
+ fieldNames = [fieldNames];
+ }
+ forceFields = {};
+ $.each(fieldNames, function (i, name) {
+ forceFields[name] = fields[name];
+ });
+ }
+ _dtCellSelector(out, dt, identifier, fields, idFn, forceFields);
+ return out;
+ },
+ prep: function (action, identifier, submit, json, store) {
+ var _this = this;
+ // Get the id of the rows created / edited
+ if (action === 'create') {
+ store.rowIds = $.map(json.data, function (row) { return dataSource$1.id.call(_this, row); });
+ }
+ if (action === 'edit') {
+ var cancelled_1 = json.cancelled || [];
+ store.rowIds = $.map(submit.data, function (val, key) {
+ return !$.isEmptyObject(submit.data[key]) && // was submitted
+ $.inArray(key, cancelled_1) === -1 ? // was not cancelled on the server-side
+ key :
+ undefined;
+ });
+ }
+ else if (action === 'remove') {
+ store.cancelled = json.cancelled || [];
+ }
+ },
+ refresh: function () {
+ // Reload a table's data - used when nested data is changed
+ var dt = _dtApi(this.s.table);
+ dt.ajax.reload(null, false);
+ },
+ remove: function (identifier, fields, store) {
+ // No confirmation from the server
+ var that = this;
+ var dt = _dtApi(this.s.table);
+ var cancelled = store.cancelled;
+ if (cancelled.length === 0) {
+ // No rows were cancelled on the server-side, remove them all
+ dt.rows(identifier).remove();
+ }
+ else {
+ // One or more rows were cancelled, so we need to identify them
+ // and not remove those rows
+ var indexes_1 = [];
+ dt.rows(identifier).every(function () {
+ var id = dataSource$1.id.call(that, this.data());
+ if ($.inArray(id, cancelled) === -1) {
+ // Don't use `remove` here - it messes up the indexes
+ indexes_1.push(this.index());
+ }
+ });
+ dt.rows(indexes_1).remove();
+ }
+ }
+};
+
+/* - - - - - - - -
+ * HTML editor interface
+ */
+function _htmlId(identifier) {
+ if (identifier === 'keyless') {
+ return $(document);
+ }
+ var specific = $('[data-editor-id="' + identifier + '"]');
+ if (specific.length === 0) {
+ specific = typeof identifier === 'string' ?
+ $(safeQueryId(identifier)) :
+ $(identifier);
+ }
+ if (specific.length === 0) {
+ throw new Error('Could not find an element with `data-editor-id` or `id` of: ' + identifier);
+ }
+ return specific;
+}
+function _htmlEl(identifier, name) {
+ var context = _htmlId(identifier);
+ return $('[data-editor-field="' + name + '"]', context);
+}
+function _htmlEls(identifier, names) {
+ var out = $();
+ for (var i = 0, ien = names.length; i < ien; i++) {
+ out = out.add(_htmlEl(identifier, names[i]));
+ }
+ return out;
+}
+function _htmlGet(identifier, dataSrc) {
+ var el = _htmlEl(identifier, dataSrc);
+ return el.filter('[data-editor-value]').length ?
+ el.attr('data-editor-value') :
+ el.html();
+}
+function _htmlSet(identifier, fields, data) {
+ $.each(fields, function (name, field) {
+ var val = field.valFromData(data);
+ if (val !== undefined) {
+ var el = _htmlEl(identifier, field.dataSrc());
+ if (el.filter('[data-editor-value]').length) {
+ el.attr('data-editor-value', val);
+ }
+ else {
+ el.each(function () {
+ // This is very frustrating, but in IE if you just write directly
+ // to innerHTML, and elements that are overwritten are GC'ed,
+ // even if there is a reference to them elsewhere
+ while (this.childNodes.length) {
+ this.removeChild(this.firstChild);
+ }
+ })
+ .html(val);
+ }
+ }
+ });
+}
+var dataSource = {
+ create: function (fields, data) {
+ // If there is an element with the id that has been created, then use it
+ // to assign the values
+ if (data) {
+ var id = dataSource.id.call(this, data);
+ try {
+ if (_htmlId(id).length) {
+ _htmlSet(id, fields, data);
+ }
+ }
+ catch (e) {
+ // noop - use `postCreate` to add items to the DOM
+ }
+ }
+ },
+ edit: function (identifier, fields, data) {
+ // Get the ids from the returned data or `keyless` if not found
+ var id = dataSource.id.call(this, data) || 'keyless';
+ _htmlSet(id, fields, data);
+ },
+ // get idSrc, fields to edit, data and node for each item
+ fields: function (identifier) {
+ var out = {};
+ // Allow multi-point editing
+ if (Array.isArray(identifier)) {
+ for (var i = 0, ien = identifier.length; i < ien; i++) {
+ var res = dataSource.fields.call(this, identifier[i]);
+ out[identifier[i]] = res[identifier[i]];
+ }
+ return out;
+ }
+ // else
+ var data = {};
+ var fields = this.s.fields;
+ if (!identifier) {
+ identifier = 'keyless';
+ }
+ $.each(fields, function (name, field) {
+ var val = _htmlGet(identifier, field.dataSrc());
+ // If no HTML element is present, jQuery returns null. We want undefined
+ field.valToData(data, val === null ? undefined : val);
+ });
+ out[identifier] = {
+ data: data,
+ fields: fields,
+ idSrc: identifier,
+ node: document,
+ type: 'row'
+ };
+ return out;
+ },
+ id: function (data) {
+ var idFn = dataGet(this.s.idSrc);
+ return idFn(data);
+ },
+ individual: function (identifier, fieldNames) {
+ var attachEl;
+ // Auto detection of the field name and id
+ if (identifier instanceof $ || identifier.nodeName) {
+ attachEl = identifier;
+ if (!fieldNames) {
+ fieldNames = [$(identifier).attr('data-editor-field')];
+ }
+ var back = $.fn.addBack ? 'addBack' : 'andSelf';
+ identifier = $(identifier).parents('[data-editor-id]')[back]().data('editor-id');
+ }
+ // no id given and none found
+ if (!identifier) {
+ identifier = 'keyless';
+ }
+ // no field name - cannot continue
+ if (fieldNames && !Array.isArray(fieldNames)) {
+ fieldNames = [fieldNames];
+ }
+ if (!fieldNames || fieldNames.length === 0) {
+ throw new Error('Cannot automatically determine field name from data source');
+ }
+ var out = dataSource.fields.call(this, identifier);
+ var fields = this.s.fields;
+ var forceFields = {};
+ $.each(fieldNames, function (i, name) {
+ forceFields[name] = fields[name];
+ });
+ $.each(out, function (id, set) {
+ set.type = 'cell';
+ set.attachFields = [fieldNames];
+ set.attach = attachEl ?
+ $(attachEl) :
+ _htmlEls(identifier, fieldNames).toArray();
+ set.fields = fields;
+ set.displayFields = forceFields;
+ });
+ return out;
+ },
+ initField: function (cfg) {
+ // This is before the field has been initialised so can't use it API
+ var label = $('[data-editor-label="' + (cfg.data || cfg.name) + '"]');
+ if (!cfg.label && label.length) {
+ cfg.label = label.html();
+ }
+ },
+ remove: function (identifier, fields) {
+ // If there is an element with an ID property matching the identifier,
+ // remove it
+ if (identifier !== 'keyless') {
+ _htmlId(identifier).remove();
+ }
+ }
+};
+
+/**
+ * Class names that are used by Editor for its various display components.
+ * A copy of this object is taken when an Editor instance is initialised, thus
+ * allowing different classes to be used in different instances if required.
+ * Class name changes can be useful for easy integration with CSS frameworks,
+ * for example Twitter Bootstrap.
+ *
+ * @namespace
+ */
+var classNames = {
+ /**
+ * Action classes - these are added to the Editor base element ("wrapper")
+ * and allows styling based on the type of form view that is being employed.
+ *
+ * @namespace
+ */
+ actions: {
+ /**
+ * Editor is in 'create' state
+ */
+ create: 'DTE_Action_Create',
+ /**
+ * Editor is in 'edit' state
+ */
+ edit: 'DTE_Action_Edit',
+ /**
+ * Editor is in 'remove' state
+ */
+ remove: 'DTE_Action_Remove'
+ },
+ /**
+ * Display body classes
+ *
+ * @namespace
+ */
+ body: {
+ /**
+ * Liner for the body content
+ */
+ content: 'DTE_Body_Content',
+ /**
+ * Container for the body elements
+ */
+ wrapper: 'DTE_Body'
+ },
+ /**
+ * Bubble editing classes - these are used to display the bubble editor
+ *
+ * @namespace
+ */
+ bubble: {
+ /**
+ * Fixed background
+ */
+ bg: 'DTE_Bubble_Background',
+ /**
+ * Close button
+ */
+ close: 'icon close',
+ /**
+ * Bubble content liner
+ */
+ liner: 'DTE_Bubble_Liner',
+ /**
+ * Pointer shown which node is being edited
+ */
+ pointer: 'DTE_Bubble_Triangle',
+ /**
+ * Bubble table display wrapper, so the buttons and form can be shown
+ * as table cells (via css)
+ */
+ table: 'DTE_Bubble_Table',
+ /**
+ * Bubble container element
+ */
+ wrapper: 'DTE DTE_Bubble'
+ },
+ /**
+ * Field classes
+ *
+ * @namespace
+ */
+ field: {
+ /**
+ * Field is disabled
+ */
+ 'disabled': 'disabled',
+ /**
+ * Field error state (added to the field.wrapper element when in error state
+ */
+ 'error': 'DTE_Field_StateError',
+ /**
+ * Field input container
+ */
+ 'input': 'DTE_Field_Input',
+ /**
+ * Input elements wrapper
+ */
+ 'inputControl': 'DTE_Field_InputControl',
+ /**
+ * Field label
+ */
+ 'label': 'DTE_Label',
+ /**
+ * Error information text
+ */
+ 'msg-error': 'DTE_Field_Error',
+ /**
+ * General information text
+ */
+ 'msg-info': 'DTE_Field_Info',
+ /**
+ * Label information text
+ */
+ 'msg-label': 'DTE_Label_Info',
+ /**
+ * Live messaging (API) information text
+ */
+ 'msg-message': 'DTE_Field_Message',
+ /**
+ * Multi-value information descriptive text
+ */
+ 'multiInfo': 'multi-info',
+ /**
+ * Multi-value not editable (field.multiEditable)
+ */
+ 'multiNoEdit': 'multi-noEdit',
+ /**
+ * Multi-value information display
+ */
+ 'multiRestore': 'multi-restore',
+ /**
+ * Multi-value information display wrapper
+ */
+ 'multiValue': 'multi-value',
+ /**
+ * Class prefix for the field name - field name is added to the end allowing
+ * styling based on field name.
+ */
+ 'namePrefix': 'DTE_Field_Name_',
+ /**
+ * Field's processing element
+ */
+ 'processing': 'DTE_Processing_Indicator',
+ /**
+ * Class prefix for the field type - field type is added to the end allowing
+ * styling based on field type.
+ */
+ 'typePrefix': 'DTE_Field_Type_',
+ /**
+ * Container for each field
+ */
+ 'wrapper': 'DTE_Field'
+ },
+ /**
+ * Display footer classes
+ *
+ * @namespace
+ */
+ footer: {
+ /**
+ * Liner for the footer content
+ */
+ content: 'DTE_Footer_Content',
+ /**
+ * Container for the footer elements
+ */
+ wrapper: 'DTE_Footer'
+ },
+ /**
+ * Form classes
+ *
+ * @namespace
+ */
+ form: {
+ /**
+ * Button
+ */
+ button: 'btn',
+ /**
+ * Button inside the form
+ */
+ buttonInternal: 'btn',
+ /**
+ * Buttons container
+ */
+ buttons: 'DTE_Form_Buttons',
+ /**
+ * Liner for the form content
+ */
+ content: 'DTE_Form_Content',
+ /**
+ * Global error imformation
+ */
+ error: 'DTE_Form_Error',
+ /**
+ * Global form information
+ */
+ info: 'DTE_Form_Info',
+ /**
+ * Applied to the |