');
var attachFields = [];
var attach = [];
var displayFields = {};
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 cell = dt.cell(':eq(0)', visIdx).node();
if (cell) {
td.addClass(cell.className);
}
if (Object.keys(fields).length) {
attachFields.push(Object.keys(fields));
attach.push(td[0]);
$.extend(displayFields, fields);
}
}
var append = function () {
var action = insertPoint === 'end'
? 'appendTo'
: 'prependTo';
tr[action](dt.table(undefined).body());
};
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;
},
// 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
_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 |