MIT license
+ // The code can be found on https://github.com/felixge/node-dateformat/blob/master/lib/dateformat.js
+ // It would be probabbly good idea to support original date format additionally to the
+ // PHP data format used below.
+ var token = /\\.|[dDjlNSwzWFmMntLoYyaABgGhHisueIOPTZcrU]/g, dM, k, hl, timestamp = 0, offset = 0,
+ timezone = /\b(?:[PMCEA][SDP]T|(?:Pacific|Mountain|Central|Eastern|Atlantic) (?:Standard|Daylight|Prevailing) Time|(?:GMT|UTC)(?:[\-+]\d{4})?)\b/g,
+ timezoneClip = /[^\-+\dA-Z]/g,
+ msMatch = ((typeof date === "string") ? date.match(/^\/Date\((([\-+])?[0-9]+)(([\-+])([0-9]{2})([0-9]{2}))?\)\/$/) : null),
+ pad = function (value, length) {
+ value = String(value);
+ length = parseInt(length, 10) || 2;
+ while (value.length < length) { value = "0" + value; }
+ return value;
+ },
+ ts = { m: 1, d: 1, y: 1970, h: 0, i: 0, s: 0, u: 0 },
+ h12To24 = function (ampm, h) {
+ if (ampm === 0) {
+ if (h === 12) { h = 0; }
+ } else {
+ if (h !== 12) { h += 12; }
+ }
+ return h;
+ },
+ getDefOptions = function (p, options) {
+ // It could be multiple sources for date properties used below.
+ // Let us we need to use srcformat. The highest priority have
+ // opts.srcformat if it is specified. If the srcformat is not
+ // specified of if opts is undefined then one should use
+ // $.jgrid.locales.de.formatter.date.srcformat, for example,
+ // where "de" part is an example of the locale of the grid
+ // ($t.p.locale). There as the third important case existing
+ // because of compatibility only. The old place for formatter.date.srcformat
+ // was $.jgrid.formatter.date.srcformat (without "locales.de" part
+ // in the middle). Now such option should be not used, but
+ // because of some code where the old code of jqGrid was customized
+ // using $.jgrid.formatter instead of $.jgrid.locales[locale].formatter,
+ // one have to take in consideration the case. If such setting exist
+ // then one should use it (should use $.jgrid.formatter.date.srcformat)
+ // BEFORE the new default $.jgrid.locales.de.formatter.date.srcformat.
+ // As the result sue should search for all below properties in 3 sources:
+ // first in opts || {}, second in
+ // ($.jgrid.formatter || {}).date || {}
+ // and finally, if $t.p != null && $t.p.locale != null, under
+ // $.jgrid.locales[$t.p.locale].formatter.date
+ // oder (it's the same, just rewritten) under
+ // ((locales[$t.p.locale] || {}).formatter || {}).date
+ var props = ["AmPm", "dayNames", "masks", "monthNames", "userLocalTime", "parseRe", "S", "srcformat"],
+ root1 = options || {},
+ root2 = (jgrid.formatter || {}).date || {},
+ root3 = ((locales[(p || $.jgrid.defaults).locale] || {}).formatter || {}).date,
+ iProp, nProps = props.length, result = {}, prop;
+ for (iProp = 0; iProp < nProps; iProp++) {
+ prop = props[iProp];
+ if (root1[prop] !== undefined) { // root1.hasOwnProperty(prop)
+ result[prop] = root1[prop];
+ } else if (root2[prop] !== undefined) {// root2.hasOwnProperty(prop)
+ result[prop] = root2[prop];
+ } else if (root3[prop] !== undefined) {// root3.hasOwnProperty(prop)
+ result[prop] = root3[prop];
+ }
+ }
+ return result;
+ };
+
+ //opts = $.extend({}, (jgrid.formatter || {}).date,
+ // $t.p != null ?
+ // jgrid.getRes(locales[$t.p.locale], "formatter.date") || {} :
+ // {},
+ // opts || {});
+ opts = getDefOptions(this.p, opts);
+ // old lang files
+ if (opts.parseRe === undefined) {
+ opts.parseRe = /[#%\\\/:_;.,\t\s\-]/;
+ }
+ if (opts.masks.hasOwnProperty(format)) { format = opts.masks[format]; }
+ if (date && date != null) {
+ if (!isNaN(date) && String(format).toLowerCase() === "u") {
+ //Unix timestamp
+ timestamp = new Date(parseFloat(date) * 1000);
+ } else if (!isNaN(date) && String(format).toLowerCase() === "u1000") {
+ // Milliseconds since the Unix Epoch (January 1 1970 00:00:00 GMT)
+ timestamp = new Date(parseFloat(date));
+ } else if (date.constructor === Date) {
+ timestamp = date;
+ // Microsoft date format support
+ } else if (msMatch !== null) {
+ timestamp = new Date(parseInt(msMatch[1], 10));
+ if (msMatch[3]) {
+ offset = Number(msMatch[5]) * 60 + Number(msMatch[6]);
+ offset *= ((msMatch[4] === "-") ? 1 : -1);
+ offset -= timestamp.getTimezoneOffset();
+ timestamp.setTime(Number(Number(timestamp) + (offset * 60 * 1000)));
+ }
+ } else {
+ //Support ISO8601Long that have Z at the end to indicate UTC timezone
+ if (opts.srcformat === "ISO8601Long" && date.charAt(date.length - 1) === "Z") {
+ offset -= (new Date()).getTimezoneOffset();
+ }
+ date = String(date).replace(/\T/g, "#").replace(/\t/, "%").split(opts.parseRe);
+ format = format.replace(/\T/g, "#").replace(/\t/, "%").split(opts.parseRe);
+ // parsing for month names and time
+ for (k = 0, hl = Math.min(format.length, date.length); k < hl; k++) {
+ switch (format[k]) {
+ case "M":
+ // A short textual representation of a month, three letters Jan through Dec
+ dM = $.inArray(date[k], opts.monthNames);
+ if (dM !== -1 && dM < 12) {
+ date[k] = dM + 1;
+ ts.m = date[k];
+ }
+ break;
+ case "F":
+ // A full textual representation of a month, such as January or March
+ dM = $.inArray(date[k], opts.monthNames, 12);
+ if (dM !== -1 && dM > 11) {
+ date[k] = dM + 1 - 12;
+ ts.m = date[k];
+ }
+ break;
+ case "n":
+ // Numeric representation of a month, without leading zeros 1 through 12
+ ts.m = parseInt(date[k], 10);
+ break;
+ case "j":
+ // Day of the month without leading zeros 1 to 31
+ ts.d = parseInt(date[k], 10);
+ break;
+ case "g":
+ // 12-hour format of an hour without leading zeros 1 through 12
+ ts.h = parseInt(date[k], 10);
+ break;
+ case "a":
+ // Lowercase Ante meridiem and Post meridiem am or pm
+ dM = $.inArray(date[k], opts.AmPm);
+ if (dM !== -1 && dM < 2 && date[k] === opts.AmPm[dM]) {
+ date[k] = dM;
+ ts.h = h12To24(date[k], ts.h);
+ }
+ break;
+ case "A":
+ // Uppercase Ante meridiem and Post meridiem AM or PM
+ dM = $.inArray(date[k], opts.AmPm);
+ if (dM !== -1 && dM > 1 && date[k] === opts.AmPm[dM]) {
+ date[k] = dM - 2;
+ ts.h = h12To24(date[k], ts.h);
+ }
+ break;
+ }
+ if (date[k] !== undefined) {
+ ts[format[k].toLowerCase()] = parseInt(date[k], 10);
+ }
+ }
+ if (ts.f) { ts.m = ts.f; }
+ if (ts.m === 0 && ts.y === 0 && ts.d === 0) {
+ return " ";
+ }
+ ts.m = parseInt(ts.m, 10) - 1;
+ var ty = ts.y;
+ if (ty >= 70 && ty <= 99) {
+ ts.y = 1900 + ts.y;
+ } else if (ty >= 0 && ty <= 69) {
+ ts.y = 2000 + ts.y;
+ }
+ timestamp = new Date(ts.y, ts.m, ts.d, ts.h, ts.i, ts.s, ts.u);
+ //Apply offset to show date as local time.
+ if (offset !== 0) {
+ timestamp.setTime(Number(Number(timestamp) + (offset * 60 * 1000)));
+ }
+ }
+ } else {
+ timestamp = new Date(ts.y, ts.m, ts.d, ts.h, ts.i, ts.s, ts.u);
+ }
+ if (opts.userLocalTime && offset === 0) {
+ offset -= (new Date()).getTimezoneOffset();
+ if (offset !== 0) {
+ timestamp.setTime(Number(Number(timestamp) + (offset * 60 * 1000)));
+ }
+ }
+ if (newformat === undefined) {
+ return timestamp;
+ }
+ if (opts.masks.hasOwnProperty(newformat)) {
+ newformat = opts.masks[newformat];
+ } else if (!newformat) {
+ newformat = "Y-m-d";
+ }
+ if (newformat.toLowerCase() === "u1000") {
+ return timestamp.getTime();
+ }
+ var hours = timestamp.getHours(), // a Number, from 0 to 23, representing the hour
+ i = timestamp.getMinutes(),
+ j = timestamp.getDate(),
+ n = timestamp.getMonth() + 1,
+ o = timestamp.getTimezoneOffset(),
+ s = timestamp.getSeconds(),
+ u = timestamp.getMilliseconds(),
+ w = timestamp.getDay(),
+ year = timestamp.getFullYear(), // a Number, representing four digits, representing the year. Examples: 1999 or 2003
+ dayOfWeek = (w + 6) % 7 + 1, // numeric representation of the day of the week. 1 (for Monday) through 7 (for Sunday)
+ z = (new Date(year, n - 1, j) - new Date(year, 0, 1)) / 86400000,
+ weekNumberOfYear = dayOfWeek < 5 ?
+ Math.floor((z + dayOfWeek - 1) / 7) + 1 :
+ Math.floor((z + dayOfWeek - 1) / 7) || ((new Date(year - 1, 0, 1).getDay() + 6) % 7 < 4 ? 53 : 52),
+ flags = {
+ // Day
+ d: pad(j), // Day of the month, 2 digits with leading zeros 01 to 31
+ D: opts.dayNames[w], // A textual representation of a day, three letters. Mon through Sun
+ j: j, // Day of the month without leading zeros 1 to 31
+ l: opts.dayNames[w + 7], // A full textual representation of the day of the week. Sunday through Saturday
+ N: dayOfWeek, // ISO-8601 numeric representation of the day of the week. 1 (for Monday) through 7 (for Sunday)
+ S: opts.S(j), // English ordinal suffix for the day of the month, 2 characters. st, nd, rd or th. Works well with j
+ w: w, // Numeric representation of the day of the week. 0 (for Sunday) through 6 (for Saturday)
+ z: z, // The day of the year (starting from 0). 0 through 365
+ // Week.
+ W: weekNumberOfYear, // ISO-8601 week number of year, weeks starting on Monday. Example: 42 (the 42nd week in the year)
+ // Month
+ F: opts.monthNames[n - 1 + 12], // A full textual representation of a month, such as January or March. January through December
+ m: pad(n), // Numeric representation of a month, with leading zeros. 01 through 12
+ M: opts.monthNames[n - 1], // A short textual representation of a month, three letters. Jan through Dec
+ n: n, // Numeric representation of a month, without leading zeros. 1 through 12
+ t: "?", // Number of days in the given month. 28 through 31
+ // Year
+ L: "?", // Whether it's a leap year. 1 if it is a leap year, 0 otherwise.
+ o: "?", // SO-8601 year number. This has the same value as Y, except that if the ISO week number (W) belongs to the previous or next year, that year is used instead. Examples: 1999 or 2003
+ Y: year, // A full numeric representation of a year, 4 digits. Examples: 1999 or 2003
+ y: String(year).substring(2), // A two digit representation of a year. Examples: 99 or 03
+ // Time
+ a: hours < 12 ? opts.AmPm[0] : opts.AmPm[1], // Lowercase Ante meridiem and Post meridiem: am or pm
+ A: hours < 12 ? opts.AmPm[2] : opts.AmPm[3], // Uppercase Ante meridiem and Post meridiem: AM or PM
+ B: "?", // Swatch Internet time 000 through 999
+ g: hours % 12 || 12, // 12-hour format of an hour without leading zeros 1 through 12
+ G: hours, // 24-hour format of an hour without leading zeros. 0 through 23
+ h: pad(hours % 12 || 12), // 12-hour format of an hour with leading zeros: 01 through 12
+ H: pad(hours), // 24-hour format of an hour with leading zeros: 00 through 23
+ i: pad(i), // Minutes with leading zeros: 00 to 59
+ s: pad(s), // Seconds, with leading zeros: 00 through 59
+ u: u, // Microseconds. Example: 654321
+ // Timezone
+ e: "?", // Timezone identifier. Examples: UTC, GMT, Atlantic/Azores
+ I: "?", // Whether or not the date is in daylight saving time. 1 if Daylight Saving Time, 0 otherwise.
+ O: (o > 0 ? "-" : "+") + pad(Math.floor(Math.abs(o) / 60) * 100 + Math.abs(o) % 60, 4), // Difference to Greenwich time (GMT) in hours. Example: +0200
+ P: "?", // Difference to Greenwich time (GMT) with colon between hours and minutes. Example: +02:00
+ T: (String(timestamp).match(timezone) || [""]).pop().replace(timezoneClip, ""), // Timezone abbreviation. Examples: EST, MDT
+ Z: "?", // Timezone offset in seconds. The offset for timezones west of UTC is always negative, and for those east of UTC is always positive. -43200 through 50400
+ // Full Date/Time
+ c: "?", // ISO 8601 date. Example: 2004-02-12T15:19:21+00:00
+ r: "?", // RFC 2822 formatted date. Example: Thu, 21 Dec 2000 16:01:07 +0200
+ U: Math.floor(timestamp / 1000) // Seconds since the Unix Epoch (January 1 1970 00:00:00 GMT)
+ };
+ return newformat.replace(token, function ($0) {
+ return flags.hasOwnProperty($0) ? flags[$0] : $0.substring(1);
+ });
+ },
+ parseDateToNumber: function (format, date) {
+ var datetime = jgrid.parseDate.call(this, format, date);
+ // datetime could be the string " "
+ return datetime instanceof Date ? datetime.getTime() : 0;
+ },
+ jqID: function (sid) {
+ return String(sid).replace(/[!"#$%&'()*+,.\/:; <=>?@\[\\\]\^`{|}~]/g, "\\$&");
+ },
+ /**
+ * @param {COMPONENT_NAMES} componentName
+ */
+ getGridComponentId: function (componentName) {
+ var self = this;
+ if (self.p == null || !self.p.id) {
+ return ""; // return empty string
+ }
+ var id = self.p.id;
+ switch (componentName) {
+ case COMPONENT_NAMES.GRID:
+ return id;
+ case COMPONENT_NAMES.GRID_BOX_DIV:
+ return "gbox_" + id;
+ case COMPONENT_NAMES.GRID_VIEW_DIV:
+ return "gview_" + id;
+ case COMPONENT_NAMES.DIALOG_ALERT_DIV: // footer/summary table
+ return "alertmod_" + id;
+ case COMPONENT_NAMES.COLUMN_RESIZER_DIV:
+ return "rs_m" + id;
+ case COMPONENT_NAMES.HEADER_SELECT_ALL_ROWS_CHECKBOX:
+ return "cb_" + id;
+ case COMPONENT_NAMES.SEARCH_OPERATION_MENU_UL:
+ return "sopt_menu";
+ default:
+ return ""; // return empty string
+ }
+ },
+ /**
+ * @param {COMPONENT_NAMES} componentName
+ */
+ getGridComponentIdSelector: function (componentName) {
+ var id = jgrid.getGridComponentId.call(this, componentName);
+ return id ? "#" + jgrid.jqID(id) : "";
+ },
+ isHTMLElement: function (elem) {
+ // see http://stackoverflow.com/a/384380/315935
+ return (typeof HTMLElement === "object" || typeof HTMLElement === "function") ?
+ elem instanceof HTMLElement : //DOM2
+ elem != null && typeof elem === "object" && elem.nodeType === 1 && typeof elem.nodeName === "string";
+ },
+ /**
+ * @param {COMPONENT_NAMES} componentName
+ */
+ getGridComponent: function (componentName, $p) {// , p1
+ var p;
+ if ($p instanceof $ || $p.length > 0) {
+ p = $p[0];
+ } else if (jgrid.isHTMLElement($p)) {
+ p = $p;
+ $p = $(p);
+ } else {
+ return $(); // return empty jQuery object
+ }
+ switch (componentName) {
+ case COMPONENT_NAMES.BODY_TABLE: // get body table from bDiv
+ return $p.hasClass("ui-jqgrid-bdiv") ? $p.children("div").children(".ui-jqgrid-btable") : $();
+ case COMPONENT_NAMES.HEADER_TABLE: // header table from bDiv
+ return $p.hasClass("ui-jqgrid-hdiv") ? $p.children("div").children(".ui-jqgrid-htable") : $();
+ case COMPONENT_NAMES.FOOTER_TABLE: // footer/summary table from sDiv
+ return $p.hasClass("ui-jqgrid-sdiv") ? $p.children("div").children(".ui-jqgrid-ftable") : $();
+ case COMPONENT_NAMES.FROZEN_HEADER_TABLE: // header table from bDiv
+ return $p.hasClass("ui-jqgrid-hdiv") ? $p.children(".ui-jqgrid-htable") : $();
+ case COMPONENT_NAMES.FROZEN_FOOTER_TABLE: // footer/summary table from sDiv
+ return $p.hasClass("ui-jqgrid-sdiv") ? $p.children(".ui-jqgrid-ftable") : $();
+ case COMPONENT_NAMES.BODY_DIV: // get bDiv of grid (bTable)
+ return $p.hasClass("ui-jqgrid-btable") && p.grid != null ? $(p.grid.bDiv) : $();
+ case COMPONENT_NAMES.HEADER_DIV: // get hDiv of grid (bTable)
+ return $p.hasClass("ui-jqgrid-btable") && p.grid != null ? $(p.grid.hDiv) : $();
+ case COMPONENT_NAMES.FOOTER_DIV: // get sDiv of grid (bTable)
+ return $p.hasClass("ui-jqgrid-btable") && p.grid != null ? $(p.grid.sDiv) : $();
+ //case "colHeader": // p should be iCol
+ // return !isNaN(p1) && p.grid != null && p.grid.headers != null && p.grid.headers[p1] != null ?
+ // $(p.grid.headers[p1].el) : $();
+ default:
+ return $(); // return empty jQuery object
+ }
+ },
+ fixScrollOffsetAndhBoxPadding: function () {
+ var self = this, grid = self.grid;
+ if (!grid) {
+ return;
+ }
+
+ var p = self.p, bDiv = grid.bDiv,
+ fixhBox = function (hDiv) {
+ var $hDivhBox = $(hDiv).children("div").first();
+ $hDivhBox.css($hDivhBox.hasClass("ui-jqgrid-hbox-rtl") ? "padding-left" : "padding-right", p.scrollOffset);
+ hDiv.scrollLeft = bDiv.scrollLeft;
+ };
+ if ($(bDiv).width() > 0) {
+ p.scrollOffset = (bDiv.offsetWidth - bDiv.clientWidth); // can be 0 if no scrollbar exist
+ // TODO: add detection of the width of vertical scroll bar if the grid is hidden
+ // at the moment of executing fixScrollOffsetAndhBoxPadding (for example inside of inactive jQuery UI Tab)
+ // one need just create close construction with visible:hidden style, add to body and get its width
+ fixhBox(grid.hDiv);
+ if (grid.sDiv) {
+ fixhBox(grid.sDiv);
+ }
+ }
+ },
+ mergeCssClasses: function () {
+ var args = $.makeArray(arguments), map = {}, i, j, ar, cssClass, classes = [];
+ for (i = 0; i < args.length; i++) {
+ ar = String(args[i]).replace(/[\t\r\n\f]/g, " ").split(" ");
+ for (j = 0; j < ar.length; j++) {
+ cssClass = ar[j];
+ if (cssClass !== "" && !map.hasOwnProperty(cssClass)) {
+ map[cssClass] = true;
+ classes.push(cssClass);
+ }
+ }
+ }
+ return classes.join(" ");
+ },
+ hasOneFromClasses: function (elem, classes) {
+ var $elem = $(elem),
+ arClasses = String(classes).replace(/[\t\r\n\f]/g, " ").split(" "),
+ n = arClasses.length,
+ i;
+ for (i = 0; i < n; i++) {
+ if ($elem.hasClass(arClasses[i])) {
+ return true;
+ }
+ }
+ return false;
+ },
+ hasAllClasses: function (elem, classes) {
+ // the current implementation of jQuery.hasClass can work with multiple classes,
+ // but the classes HAVE TO BE in exact the same order. jQuery.hasClass just
+ // search for classes using indexOf.
+ // (see https://github.com/jquery/jquery/blob/1.11.3/src/attributes/classes.js#L143-L154)
+ // Thus we cant's use it to test whether an element has the list of all the classes
+ // and we introduces the helper method hasAllClasses
+ var $elem = $(elem),
+ arClasses = String(classes).replace(/[\t\r\n\f]/g, " ").split(" "),
+ n = arClasses.length,
+ i;
+ for (i = 0; i < n; i++) {
+ if (!$elem.hasClass(arClasses[i])) {
+ return false;
+ }
+ }
+ return true;
+ },
+ detectRowEditing: function (rowid) {
+ //var i, savedRowInfo, tr, self = this, rows = self.rows, p = self.p, isFunction = $.isFunction;
+ if (!this.grid || this.p == null || this.p.editingInfo == null || this.p.editingInfo[rowid] == null) {
+ return null; // this is not a grid or the row is not editing now
+ }
+ return this.p.editingInfo[rowid];
+ },
+ // The method returns jQuery wrapper with the cell () of the row.
+ // It can return jQuery wrapper with two cells in case of usage frozen data:
+ // one cell of the main grid and another cell with the corresponding cell from the frozen body table
+ getCell: function (tr, iCol) {
+ var grid = this.grid, p = this.p, frozenRows, $td;
+ if (!grid || !p) { return $(); } // not a grid
+ if (tr instanceof $ || tr.length > 0) {
+ tr = tr[0]; // unwrap jQuery object to DOM element
+ }
+ if (!((typeof HTMLTableRowElement === "object" || typeof HTMLTableRowElement === "function") && tr instanceof HTMLTableRowElement) || tr.cells == null) { // the line will be failed in IE7
+ return $(); // return empty jQuery object
+ }
+ $td = $(tr.cells[iCol]);
+ frozenRows = grid.fbRows;
+ return frozenRows != null && iCol < frozenRows[0].cells.length ?
+ $td.add(frozenRows[tr.rowIndex].cells[iCol]) :
+ $td;
+ },
+ getDataFieldOfCell: function (tr, iCol) {
+ var p = this.p, $td = jgrid.getCell.call(this, tr, iCol), $dataElement;
+ if (p.treeGrid && $td.children("div.tree-wrap").length > 0) {
+ $td = $td.children("span.cell-wrapperleaf,span.cell-wrapper");
+ }
+ if (p.colModel[iCol].autoResizable) {
+ $dataElement = $td.children("span." + p.autoResizing.wrapperClassName);
+ if ($dataElement.length === 0) { // for example, td is in editing mode
+ $dataElement = $td;
+ }
+ } else {
+ $dataElement = $td;
+ }
+ return $dataElement;
+ },
+ enumEditableCells: function (tr, mode, callback) {
+ var self = this, grid = self.grid, rows = self.rows, p = self.p;
+ if (grid == null || rows == null || p == null || tr == null || tr.rowIndex == null || !tr.id || !$.isFunction(callback)) {
+ return null; // this is not a grid or tr is not tr
+ }
+ var iCol, colModel = p.colModel, nCol = colModel.length, cm, nm, options, id, pos, item,
+ isEditable, iRow = tr.rowIndex, td, $dataElement, dataWidth,
+ frozenRows = grid.fbRows, frozen = frozenRows != null,
+ trFrozen = frozen ? frozenRows[iRow] : null;
+
+ // normalize tr if required
+ if (frozen/* && !$.contains(self, tr)*/) {
+ // The event could be inside of frozen div.
+ // Thus tr could be the same as trFrozen
+ // We normalize it based on the rowIndex.
+ tr = self.rows[iRow];
+ }
+
+ for (iCol = 0; iCol < nCol; iCol++) {
+ cm = colModel[iCol];
+ nm = cm.name;
+ if (nm !== "cb" && nm !== "subgrid" && nm !== "rn") {
+ if (frozen && !cm.frozen) {
+ frozen = false;
+ }
+ td = (frozen ? trFrozen : tr).cells[iCol];
+ $dataElement = $(td);
+ if (!$dataElement.hasClass("not-editable-cell")) {
+ dataWidth = $dataElement.width();
+ if (p.treeGrid === true && nm === p.ExpandColumn) {
+ dataWidth -= $dataElement.children("div.tree-wrap").outerWidth();
+ $dataElement = $dataElement.children("span.cell-wrapperleaf,span.cell-wrapper").first();
+ } else {
+ dataWidth = 0; // we can test it in the callback and use width:auto in the case
+ }
+
+ id = stripPref(p.idPrefix, tr.id);
+ options = {
+ rowid: tr.id,
+ id: id,
+ iCol: iCol,
+ iRow: iRow,
+ cmName: nm,
+ cm: cm,
+ mode: mode,
+ td: td,
+ tr: tr,
+ trFrozen: trFrozen,
+ dataElement: $dataElement[0],
+ dataWidth: dataWidth
+ };
+ if (p.datatype === "local") {
+ pos = p._index[id];
+ item = pos != null ? p.data[pos] : undefined;
+ if (item) {
+ options.item = item;
+ }
+ }
+ if (!cm.edittype) { cm.edittype = "text"; }
+ if (((p.editingInfo[tr.id] || {}).editable || {}).hasOwnProperty(nm)) {
+ // if the cell in already editing
+ isEditable = p.editingInfo[tr.id].editable[nm];
+ } else {
+ isEditable = cm.editable;
+ isEditable = $.isFunction(isEditable) ?
+ isEditable.call(self, options) :
+ isEditable;
+ }
+ if (isEditable === true || isEditable === "hidden") {
+ options.editable = isEditable;
+ if (callback.call(self, options) === false) { break; }
+ }
+ }
+ }
+ }
+ },
+ getEditedValue: function ($dataFiled, cm, valueText, editable) {
+ var result, checkBoxValues, newformat, $field, values, texts,
+ formatoptions = cm.formatoptions || {}, editoptions = cm.editoptions || {},
+ customValue = editoptions.custom_value,
+ nameSelector = "[name=" + jgrid.jqID(cm.name) + "]", $t = this, $self = $($t);
+ if (editable === "hidden" || editable === "readonly") {
+ // the implementation from the next line can be improved
+ return $($t).jqGrid("getCell", $dataFiled.closest("tr.jqgrow").attr("id"), cm.name);
+ }
+ switch (cm.edittype) {
+ case "checkbox":
+ checkBoxValues = ["Yes", "No"];
+ if (typeof editoptions.value === "string") {
+ checkBoxValues = editoptions.value.split(":");
+ }
+ result = $dataFiled.find("input[type=checkbox]").is(":checked") ? checkBoxValues[0] : checkBoxValues[1];
+ break;
+ case "text":
+ case "password":
+ case "textarea":
+ case "button":
+ $field = $dataFiled.find("input" + nameSelector + ",textarea" + nameSelector);
+ result = $field.val();
+ if ($field.prop("type") === "date" && String(result).split("-").length === 3) {
+ newformat = formatoptions.newformat || $self.jqGrid("getGridRes", "formatter.date.newformat");
+ result = jgrid.parseDate.call($t, "Y-m-d", result, newformat);
+ }
+ break;
+ case "select":
+ $field = $dataFiled.find("select option:selected");
+ if (editoptions.multiple) {
+ values = [];
+ texts = [];
+ $field.each(function () {
+ values.push($(this).val());
+ texts.push($(this).text());
+ });
+ result = values.join(",");
+ valueText.text = texts.join(",");
+ } else {
+ result = $field.val();
+ valueText.text = $field.text();
+ }
+ valueText.value = result;
+ break;
+ case "custom":
+ try {
+ if ($.isFunction(customValue)) {
+ result = customValue.call($t, $dataFiled.find(".customelement"), "get");
+ if (result === undefined) {
+ throw "e2";
+ }
+ } else {
+ throw "e1";
+ }
+ } catch (e) {
+ var errorText, infoDialog = jgrid.info_dialog,
+ getRes = function (path) { $self.jqGrid("getGridRes", path); };
+ switch (String(e)) {
+ case "e1":
+ errorText = "function 'custom_value' " + getRes("edit.msg.nodefined");
+ break;
+ case "e2":
+ break;
+ default:
+ errorText = e.message;
+ break;
+ }
+ if (infoDialog && $.isFunction(infoDialog)) {
+ infoDialog.call($t, getRes("errors.errcap"), errorText, getRes("edit.bClose"));
+ } else {
+ ($.isFunction(defaults.fatalError) ? defaults.fatalError : alert)(errorText);
+ }
+ }
+ break;
+ default:
+ result = $dataFiled.find("*" + nameSelector).text();
+ break;
+ }
+ return result;
+ },
+ guid: 1,
+ uidPref: "jqg",
+ randId: function (prefix) {
+ return (prefix || jgrid.uidPref) + (jgrid.guid++);
+ },
+ getAccessor: function (obj, expr) {
+ var ret, p, prm = [], i;
+ if ($.isFunction(expr)) { return expr(obj); }
+ if (obj != null && obj.hasOwnProperty(expr)) {
+ return obj[expr];
+ }
+ try {
+ if (typeof expr === "string") {
+ prm = expr.split(".");
+ }
+ i = prm.length;
+ if (i) {
+ ret = obj;
+ while (ret != null && i--) {
+ p = prm.shift();
+ ret = ret[p];
+ }
+ }
+ } catch (ignore) { }
+ return ret;
+ },
+ getXmlData: function (obj, expr, returnObj) {
+ var m = typeof expr === "string" ? expr.match(/^(.*)\[(\w+)\]$/) : null;
+ if ($.isFunction(expr)) { return expr(obj); }
+ if (m && m[2]) {
+ // m[2] is the attribute selector
+ // m[1] is an optional element selector
+ // examples: "[id]", "rows[page]"
+ return m[1] ? $(m[1], obj).attr(m[2]) : $(obj).attr(m[2]);
+ }
+ if (obj === undefined) {
+ //alert("expr");
+ return undefined;
+ }
+ // !!! one should never use another form $(expr, obj) if obj could be undefined
+ // In the case the $(expr, obj) could be $("someString") and jQuery can
+ // parse it as array of characters ($("someString").length will be "someString".length) !!!
+ // The problem take place if expr is not string object, but object new String("someString").
+ // The problem can exist if one use $.each with array of strings.
+ // The "this" inside of $.each is the string converted to object.
+ var ret = $(obj).find(expr);
+ if (returnObj) { return ret; }
+ //$(expr, obj).filter(":last"); // we use ":last" to be more compatible with old version of jqGrid
+ return ret.length > 0 ? $(ret).text() : undefined;
+ },
+ cellWidth: function () {
+ // TODO: use all other classes in grid. Probably one should set the visibility explicitly to show (display:block)
+ var $testDiv = $(""),
+ testCell = $testDiv.appendTo("body")
+ .find("td")
+ .width();
+ $testDiv.remove();
+ return Math.abs(testCell - 5) > 0.1;
+ },
+ isCellClassHidden: function (className) {
+ if (className == null || className === "") {
+ return false;
+ } else {
+ var $testDiv = $(""),
+ isHidden = $testDiv.appendTo("body")
+ .find("td")
+ .is(":hidden");
+ $testDiv.remove();
+ return isHidden;
+ }
+ },
+ cell_width: true,
+ ajaxOptions: {},
+ from: function (source) {
+ // Original Author Hugo Bonacci
+ // License MIT http://jlinq.codeplex.com/license
+ var context = this,
+ /**
+ * @private
+ * @class
+ */
+ QueryObject = function (d, q) {
+ var self = this,
+ _data = d,
+ _usecase = true,
+ _trim = false,
+ _query = q,
+ _stripNum = /[\$,%]/g,
+ _lastCommand = null,
+ _lastField = null,
+ _orDepth = 0,
+ _negate = false,
+ _queuedOperator = "",
+ _sorting = [],
+ toString = Object.prototype.toString;
+ if (typeof d === "object" && d.push) {
+ if (d.length > 0) {
+ if (typeof d[0] !== "object") {
+ throw "data items are not objects";
+ }
+ }
+ } else {
+ throw "data provides is not an array";
+ }
+ /**
+ * @private
+ * @type {function(): boolean}
+ */
+ this._hasData = function () {
+ return _data === null ? false : _data.length === 0 ? false : true;
+ };
+ /**
+ * @private
+ * @type {function(string): string}
+ */
+ this._getStr = function (s) {
+ var phrase = [];
+ if (_trim) {
+ phrase.push("jQuery.trim(");
+ }
+ phrase.push("String(" + s + " || '')");
+ if (_trim) {
+ phrase.push(")");
+ }
+ if (!_usecase) {
+ phrase.push(".toUpperCase()");
+ }
+ return phrase.join("");
+ };
+ /** @private */
+ this._strComp = function (val) {
+ if (typeof val === "string") {
+ return ".toString()";
+ }
+ return "";
+ };
+ /** @private */
+ this._group = function (f, u) {
+ return ({ field: f.toString(), unique: u, items: [] });
+ };
+ /** @private */
+ this._toStr = function (phrase) {
+ if (_trim) {
+ phrase = $.trim(phrase);
+ }
+ phrase = phrase.toString().replace(/\\/g, "\\\\").replace(/\"/g, "\\\"");
+ return _usecase ? phrase : phrase.toUpperCase();
+ };
+ /** @private */
+ this._funcLoop = function (func) {
+ var results = [];
+ $.each(_data, function (i, v) {
+ results.push(func(v));
+ });
+ return results;
+ };
+ /** @private */
+ this._append = function (s) {
+ var i;
+ if (_query === null) {
+ _query = "";
+ } else {
+ _query += _queuedOperator === "" ? " && " : _queuedOperator;
+ }
+ for (i = 0; i < _orDepth; i++) {
+ _query += "(";
+ }
+ if (_negate) {
+ _query += "!";
+ }
+ _query += "(" + s + ")";
+ _negate = false;
+ _queuedOperator = "";
+ _orDepth = 0;
+ };
+ /** @private */
+ this._setCommand = function (f, c) {
+ _lastCommand = f;
+ _lastField = c;
+ };
+ /** @private */
+ this._resetNegate = function () {
+ _negate = false;
+ };
+ /** @private */
+ this._repeatCommand = function (f, v) {
+ if (_lastCommand === null) {
+ return self;
+ }
+ if (f !== null && v !== null) {
+ return _lastCommand(f, v);
+ }
+ if (_lastField === null) {
+ return _lastCommand(f);
+ }
+ return _lastCommand(_lastField, f);
+ };
+ /** @private */
+ this._equals = function (a, b) {
+ return (self._compare(a, b, 1) === 0);
+ };
+ /** @private */
+ this._compare = function (a, b, dir) {
+ if (dir === undefined) { dir = 1; }
+ if (a === undefined) { a = null; }
+ if (b === undefined) { b = null; }
+ if (a === null && b === null) {
+ return 0;
+ }
+ if (a === null && b !== null) {
+ return 1;
+ }
+ if (a !== null && b === null) {
+ return -1;
+ }
+ if (toString.call(a) === "[object Date]" && toString.call(b) === "[object Date]") {
+ if (a < b) { return -dir; }
+ if (a > b) { return dir; }
+ return 0;
+ }
+ if (!_usecase && typeof a !== "number" && typeof b !== "number") {
+ a = String(a);
+ b = String(b);
+ }
+ if (a < b) { return -dir; }
+ if (a > b) { return dir; }
+ return 0;
+ };
+ /** @private */
+ this._performSort = function () {
+ if (_sorting.length === 0) { return; }
+ _data = self._doSort(_data, 0);
+ };
+ /** @private */
+ this._doSort = function (data, iSort) {
+ var by = _sorting[iSort].by,
+ dir = _sorting[iSort].dir,
+ type = _sorting[iSort].type,
+ dfmt = _sorting[iSort].datefmt,
+ sfunc = _sorting[iSort].sfunc;
+ if (iSort === _sorting.length - 1) {
+ return self._getOrder(data, by, dir, type, dfmt, sfunc);
+ }
+ iSort++;
+ var values = self._getGroup(data, by, dir, type, dfmt), results = [], i, j, sorted;
+ for (i = 0; i < values.length; i++) {
+ sorted = self._doSort(values[i].items, iSort);
+ for (j = 0; j < sorted.length; j++) {
+ results.push(sorted[j]);
+ }
+ }
+ return results;
+ };
+ /** @private */
+ this._getOrder = function (data, by, dir, type, dfmt, sfunc) {
+ var sortData = [], _sortData = [], newDir = dir === "a" ? 1 : -1, i, ab, findSortKey;
+
+ if (type === undefined) { type = "text"; }
+ if (type === "float" || type === "number" || type === "currency" || type === "numeric") {
+ findSortKey = function ($cell) {
+ var key = parseFloat(String($cell).replace(_stripNum, ""));
+ return isNaN(key) ? Number.NEGATIVE_INFINITY : key;
+ };
+ } else if (type === "int" || type === "integer") {
+ findSortKey = function ($cell) {
+ return $cell != null ? parseFloat(String($cell).replace(_stripNum, "")) : Number.NEGATIVE_INFINITY;
+ };
+ } else if (type === "date" || type === "datetime") {
+ findSortKey = function ($cell) {
+ return jgrid.parseDateToNumber.call(context, dfmt, $cell);
+ };
+ } else if ($.isFunction(type)) {
+ findSortKey = type;
+ } else {
+ findSortKey = function ($cell) {
+ $cell = $cell != null ? $.trim(String($cell)) : "";
+ return _usecase ? $cell : $cell.toUpperCase();
+ };
+ }
+ $.each(data, function (index, v) {
+ ab = by !== "" ? jgrid.getAccessor(v, by) : v;
+ if (ab === undefined) { ab = ""; }
+ ab = findSortKey.call(context, ab, v);
+ _sortData.push({ vSort: ab, data: v, index: index });
+ });
+ if ($.isFunction(sfunc)) {
+ _sortData.sort(function (a, b) {
+ return sfunc.call(context, a.vSort, b.vSort, newDir, a.data, b.data);
+ });
+ } else {
+ _sortData.sort(function (a, b) {
+ return self._compare(a.vSort, b.vSort, newDir);
+ });
+ }
+ var j = 0, nrec = data.length;
+ // overhead, but we do not change the original data.
+ while (j < nrec) {
+ i = _sortData[j].index;
+ sortData.push(data[i]);
+ j++;
+ }
+ return sortData;
+ };
+ /** @private */
+ this._getGroup = function (data, by, dir, type, dfmt) {
+ var results = [],
+ group = null,
+ last = null;
+ $.each(self._getOrder(data, by, dir, type, dfmt), function (i, v) {
+ var val = jgrid.getAccessor(v, by);
+ if (val == null) { val = ""; }
+ if (!self._equals(last, val)) {
+ last = val;
+ if (group !== null) {
+ results.push(group);
+ }
+ group = self._group(by, val);
+ }
+ group.items.push(v);
+ });
+ if (group !== null) {
+ results.push(group);
+ }
+ return results;
+ };
+ this.ignoreCase = function () {
+ _usecase = false;
+ return self;
+ };
+ this.useCase = function () {
+ _usecase = true;
+ return self;
+ };
+ this.trim = function () {
+ _trim = true;
+ return self;
+ };
+ this.noTrim = function () {
+ _trim = false;
+ return self;
+ };
+ this.execute = function () {
+ var match = _query, results = [];
+ if (match === null) {
+ return self;
+ }
+ $.each(_data, function () {
+ (function () {
+ var localMath = "(function (context) {\n" +
+ "var yesObject = { 1: 1, x: 1, \"true\": 1, yes: 1, y: 1, on: 1 }," +
+ "noObject = { 0: 1, \"false\": 1, no: 1, n: 1, off: 1 }," +
+ "normilizeBoolean = function (v) {\n" +
+ "if (typeof v === \"string\") {\n" +
+ "if (noObject[v.toLowerCase()]) { return false; } " +
+ "else if (yesObject[v.toLowerCase()]) { return true; } " +
+ "}\n" +
+ "return !!v;\n" +
+ "}," +
+ "intFunc = function (jQuery, self) { return " +
+ match +
+ "; }; return intFunc.call(context.item, context.jQuery, context.context); }(this))";
+ if (eval(localMath)) { results.push(this.item); }
+ }.call({
+ item: this,
+ jQuery: $,
+ context: context
+ }));
+ });
+ _data = results;
+ return self;
+ };
+ this.data = function () {
+ return _data;
+ };
+ this.select = function (f) {
+ self.execute();
+ if ($.isFunction(f)) {
+ var results = [];
+ $.each(_data, function (i, v) {
+ results.push(f(v));
+ });
+ return results;
+ }
+ if (!self._hasData()) { return []; }
+ self._performSort();
+ return _data;
+ };
+ this.hasMatch = function () {
+ if (!self._hasData()) { return false; }
+ self.execute();
+ return _data.length > 0;
+ };
+ this.andNot = function (f, v, x) {
+ _negate = !_negate;
+ return self.and(f, v, x);
+ };
+ this.orNot = function (f, v, x) {
+ _negate = !_negate;
+ return self.or(f, v, x);
+ };
+ this.not = function (f, v, x) {
+ return self.andNot(f, v, x);
+ };
+ this.and = function (f, v, x) {
+ _queuedOperator = " && ";
+ if (f === undefined) {
+ return self;
+ }
+ return self._repeatCommand(f, v, x);
+ };
+ this.or = function (f, v, x) {
+ _queuedOperator = " || ";
+ if (f === undefined) { return self; }
+ return self._repeatCommand(f, v, x);
+ };
+ this.orBegin = function () {
+ _orDepth++;
+ return self;
+ };
+ this.orEnd = function () {
+ if (_query !== null) {
+ _query += ")";
+ }
+ return self;
+ };
+ this.isNot = function (f) {
+ _negate = !_negate;
+ return self.is(f);
+ };
+ this.is = function (f) {
+ self._append("this." + f);
+ self._resetNegate();
+ return self;
+ };
+ /** @private */
+ this._compareValues = function (func, f, v, how, t) {
+ var fld = f;
+
+ if (v === undefined) { v = null; }
+ //var val=v===null?f:v,
+ var val = v, swst = t.stype === undefined ? "text" : t.stype;
+ if (v !== null) {
+ switch (swst) {
+ case "int":
+ case "integer":
+ val = String(val).replace(_stripNum, "");
+ val = (isNaN(Number(val)) || val === "") ? "0" : Number(val); // To be fixed with more intelligent code
+ fld = "parseInt(" + fld + "||0,10)";
+ val = String(parseInt(val, 10));
+ break;
+ case "boolean":
+ // use !! operator to convert ruthy/falsy values to boolean and then compare the values
+ fld = "normilizeBoolean(" + fld + ")";
+ val = "normilizeBoolean(" + String(val) + ")";
+ break;
+ case "float":
+ case "number":
+ case "currency":
+ case "numeric":
+ val = String(val).replace(_stripNum, "");
+ val = (isNaN(Number(val)) || val === "") ? "0" : Number(val); // To be fixed with more intelligent code
+ fld = "parseFloat(" + fld + "||0)";
+ val = String(val);
+ break;
+ case "date":
+ case "datetime":
+ val = String(jgrid.parseDateToNumber.call(context, t.newfmt || "Y-m-d", val));
+ fld = "jQuery.jgrid.parseDateToNumber.call(self,\"" + t.srcfmt + "\"," + fld + ")";
+ break;
+ default:
+ // TODO: consider to apply formatter at least to process correctly
+ // default values. For example is bootean property is not defined
+ // if will be displayed by formatter:"checkbox" as false value.
+ // If the user search for the value one will process the following
+ // jQuery.jgrid.getAccessor(this,'closed')).toUpperCase() == String("FALSE").toUpperCase()
+ // which works wrong if the property "closed" is undefined.
+ fld = self._getStr(fld);
+ val = self._getStr("\"" + self._toStr(val) + "\"");
+ }
+ }
+ self._append(fld + " " + how + " " + val);
+ self._setCommand(func, f);
+ self._resetNegate();
+ return self;
+ };
+ this.equals = function (f, v, t) {
+ return self._compareValues(self.equals, f, v, "==", t);
+ };
+ this.notEquals = function (f, v, t) {
+ return self._compareValues(self.equals, f, v, "!==", t);
+ };
+ this.isNull = function (f, v, t) {
+ return self._compareValues(self.equals, f, null, "===", t);
+ };
+ this.greater = function (f, v, t) {
+ return self._compareValues(self.greater, f, v, ">", t);
+ };
+ this.less = function (f, v, t) {
+ return self._compareValues(self.less, f, v, "<", t);
+ };
+ this.greaterOrEquals = function (f, v, t) {
+ return self._compareValues(self.greaterOrEquals, f, v, ">=", t);
+ };
+ this.lessOrEquals = function (f, v, t) {
+ return self._compareValues(self.lessOrEquals, f, v, "<=", t);
+ };
+ this.startsWith = function (f, v) {
+ var val = (v == null) ? f : v,
+ length = _trim ? $.trim(val.toString()).length : val.toString().length;
+
+ self._append(self._getStr(f) + ".substr(0," + length + ") == " + self._getStr("\"" + self._toStr(v) + "\""));
+ self._setCommand(self.startsWith, f);
+ self._resetNegate();
+ return self;
+ };
+ this.endsWith = function (f, v) {
+ var val = (v == null) ? f : v,
+ length = _trim ? $.trim(val.toString()).length : val.toString().length;
+ self._append(self._getStr(f) + ".substr(" + self._getStr(f) + ".length-" + length + "," + length + ") == \"" + self._toStr(v) + "\"");
+ self._setCommand(self.endsWith, f);
+ self._resetNegate();
+ return self;
+ };
+ this.contains = function (f, v) {
+ self._append(self._getStr(f) + ".indexOf(\"" + self._toStr(v) + "\",0) > -1");
+ self._setCommand(self.contains, f);
+ self._resetNegate();
+ return self;
+ };
+ this.groupBy = function (by, dir, type, datefmt) {
+ if (!self._hasData()) {
+ return null;
+ }
+ return self._getGroup(_data, by, dir, type, datefmt);
+ };
+ this.orderBy = function (by, dir, stype, dfmt, sfunc) {
+ dir = dir == null ? "a" : $.trim(dir.toString().toLowerCase());
+ if (stype == null) { stype = "text"; }
+ if (dfmt == null) { dfmt = "Y-m-d"; }
+ if (sfunc == null) { sfunc = false; }
+ if (dir === "desc" || dir === "descending") { dir = "d"; }
+ if (dir === "asc" || dir === "ascending") { dir = "a"; }
+ _sorting.push({ by: by, dir: dir, type: stype, datefmt: dfmt, sfunc: sfunc });
+ return self;
+ };
+ this.inSet = function (f, v, t) {
+ var val = v === undefined ? null : v,
+ swst = t.stype === undefined ? "text" : t.stype;
+
+ val = self._getStr("\"" + self._toStr(val) + "\"");
+ if (swst !== "text") {
+ // NOT yet implemented
+ return self._compareValues(self.equals, f, v, "==", t);
+ }
+
+ self._append("jQuery.inArray(" + self._getStr(f) + "," + val + ".split('" +
+ (context.p.inFilterSeparator || ",") + "')) >= 0");
+ self._setCommand(self.inSet, f);
+ self._resetNegate();
+ return self;
+ };
+ this.custom = function (ruleOp, field, data) {
+ self._append("self.p.customSortOperations." + ruleOp + ".filter.call(self,{item:this,cmName:\"" + field +
+ "\",iCol:self.p.iColByName[\"" + field + "\"]>=0 ? self.p.iColByName[\"" + field + "\"] : self.p.iPropByName[\"" + field +
+ "\"],isAddProp:self.p.iColByName[\"" + field + "\"]<0" +
+ ",searchValue:\"" + data + "\"})");
+ self._setCommand(self.custom, field);
+ self._resetNegate();
+ return self;
+ };
+ return self;
+ };
+
+ return new QueryObject(source, null);
+ },
+ serializeFeedback: function (callback, eventName, postData) {
+ var self = this, eventResult;
+ if (self instanceof $ && self.length > 0) {
+ self = self[0];
+ }
+ if (typeof postData === "string") {
+ return postData;
+ }
+ eventResult = $(self).triggerHandler(eventName, postData);
+ if (typeof eventResult === "string") {
+ return eventResult;
+ }
+ if (eventResult == null || typeof eventResult !== "object") {
+ eventResult = postData; // uses original postData
+ }
+ return $.isFunction(callback) ? callback.call(self, eventResult) : eventResult;
+ },
+ fullBoolFeedback: function (callback, eventName) {
+ var self = this, args = $.makeArray(arguments).slice(2), result = $(self).triggerHandler(eventName, args);
+
+ result = (result === false || result === "stop") ? false : true;
+ if ($.isFunction(callback)) {
+ var callbackResult = callback.apply(self, args);
+ if (callbackResult === false || callbackResult === "stop") {
+ result = false;
+ }
+ }
+ return result;
+ },
+ feedback: function (p, eventPrefix, callbackSuffix, callbackName) {
+ var self = this;
+ if (self instanceof $ && self.length > 0) {
+ self = self[0];
+ }
+ if (p == null || typeof callbackName !== "string" || callbackName.length < 2) {
+ return null; // incorrect call
+ }
+ // onSortCol -> jqGridSortCol, onSelectAll -> jqGridSelectAll, ondblClickRow -> jqGridDblClickRow
+ // resizeStop -> jqGridResizeStop
+ var eventName = callbackName.substring(0, 2) === "on" ?
+ "jqGrid" + eventPrefix + callbackName.charAt(2).toUpperCase() + callbackName.substring(3) :
+ "jqGrid" + eventPrefix + callbackName.charAt(0).toUpperCase() + callbackName.substring(1),
+ args = $.makeArray(arguments).slice(4),
+ callback = p[callbackName + callbackSuffix];
+
+ args.unshift(eventName);
+ args.unshift(callback);
+ return jgrid.fullBoolFeedback.apply(self, args);
+ },
+ builderSortIcons: function (iCol) {
+ // iCol is unused currently, but one can modify the code to set for example different sorting
+ // icons for columns based on sorttype option of colModel
+ var ts = this, p = ts.p, $self = $(ts),
+ disabledStateClasses = $self.jqGrid("getGuiStyles", "states.disabled"),
+ getClasses = function (ascOrDesc) {
+ var cm = p.colModel[iCol],
+ sortIconFunc = cm != null && $.isFunction(cm.sortIconName) ?
+ cm.sortIconName :
+ p.sortIconName;
+ var sortIconName = $.isFunction(sortIconFunc) ?
+ sortIconFunc.call(ts, {
+ order: ascOrDesc,
+ iCol: iCol,
+ cm: cm
+ }) :
+ $self.jqGrid("getIconRes", "sort." + ascOrDesc);
+ return jgrid.mergeCssClasses(
+ "ui-grid-ico-sort",
+ "ui-icon-" + ascOrDesc,
+ p.viewsortcols[1] === "horizontal" ? "ui-i-" + ascOrDesc : "",
+ disabledStateClasses,
+ sortIconName,
+ "ui-sort-" + p.direction
+ );
+ };
+
+ return "" +
+ (icon ? "" + text + " " : "") +
+ " ";
+ },
+ convertOnSaveLocally: function (nData, cm, oData, id, item, iCol) {
+ var self = this, p = self.p;
+ if (p == null) {
+ return nData;
+ }
+ if ($.isFunction(cm.convertOnSave)) {
+ return cm.convertOnSave.call(this, { newValue: nData, cm: cm, oldValue: oData, id: id, item: item, iCol: iCol });
+ }
+ if (typeof oData !== "boolean" && typeof oData !== "number") {
+ // we support first of all editing of boolean and numeric data
+ // TODO: more data types (like Date) need be implemented
+ return nData;
+ }
+
+ if (typeof oData === "boolean" && (cm.edittype === "checkbox" || cm.formatter === "checkbox")) {
+ // convert nData to boolean if possible
+ var lnData = String(nData).toLowerCase(),
+ cbv = cm.editoptions != null && typeof cm.editoptions.value === "string" ?
+ cm.editoptions.value.split(":") : ["yes", "no"];
+ if ($.inArray(lnData, ["1", "true", cbv[0].toLowerCase()]) >= 0) {
+ nData = true;
+ } else if ($.inArray(lnData, ["0", "false", cbv[1].toLowerCase()]) >= 0) {
+ nData = false;
+ }
+ } else if (typeof oData === "number" && !isNaN(nData)) {
+ if (cm.formatter === "number" || cm.formatter === "currency") {
+ nData = parseFloat(nData);
+ } else if (cm.formatter === "integer") {
+ nData = parseInt(nData, 10);
+ }
+ }
+ return nData;
+ },
+ parseDataToHtml: function (len, ids, items, cellsToDisplay, rcnt, adjust, readAllInputData) {
+ var self = this, p = self.p, $self = $(self), i, j, altr, cn1, selr, idr, rd, cells, iStartTrTag,
+ selected = false, rowData = [], grpdata = [],
+ cn = (p.altRows === true && !$self.jqGrid("isBootstrapGuiStyle")) ? p.altclass : "",
+ hiderow = p.grouping ? p.groupingView.groupCollapse === true : false,
+ rn = parseInt(p.rowNum, 10), cmName, $j = $.fn.jqGrid,
+ // prepare to build the map rowIndexes, which will simplify us to get rowIndex
+ // of any row of table by its rowid.
+ // ??? probably rcnt can be used too
+ rowIndex = p.treeGrid === true && p.treeANode > -1 ?
+ self.rows[p.treeANode].rowIndex + 1 :
+ self.rows.length,
+ formatCol = self.formatCol,
+ addCell = function (rowId, cell, pos, irow, srvr, rdata) {
+ var v = self.formatter(rowId, cell, pos, srvr, "add", rdata);
+ return " " + v + " ";
+ },
+ addMulti = function (rowid, pos, irow, checked, item) {
+ var checkboxHtml = " ", hasCbox = true,
+ callbackParams = { rowid: rowid, iRow: irow, iCol: pos, data: item, checked: checked };
+ if ($.isFunction(p.hasMultiselectCheckBox)) {
+ hasCbox = p.hasMultiselectCheckBox.call(self, callbackParams);
+ }
+ if (hasCbox) {
+ checkboxHtml = $.isFunction(p.checkboxHtml) ?
+ p.checkboxHtml.call(self, callbackParams) :
+ "" +
+ checkboxHtml + " ";
+ },
+ addRowNum = function (pos, irow, pG, rN) {
+ var v = (parseInt(pG, 10) - 1) * parseInt(rN, 10) + 1 + irow;
+ return "" + v + " ";
+ };
+ if (rowIndex <= 1) { p.rowIndexes = {}; }
+ if ((p.datatype === "local" && !p.deselectAfterSort) || p.multiPageSelection) { selected = true; }
+ if (adjust) { rn *= adjust + 1; }
+ for (i = 0; i < Math.min(len, rn); i++) {
+ idr = ids[i];
+ rd = items[i];
+ cells = cellsToDisplay != null ? cellsToDisplay[i] : rd;
+ altr = rcnt === 1 ? 0 : rcnt; // probably rowIndex should be used instead
+ cn1 = (altr + i) % 2 === 1 ? cn : "";
+ if (selected) {
+ if (p.multiselect) {
+ selr = ($.inArray(idr, p.selarrrow) !== -1);
+ if (selr && p.selrow === null) { p.selrow = idr; }
+ } else {
+ selr = (idr === p.selrow);
+ }
+ } else {
+ selr = false;
+ }
+ iStartTrTag = rowData.length;
+ rowData.push(""); // it will be replaced. See rowData[iStartTrTag] below
+ for (j = 0; j < p.colModel.length; j++) {
+ cmName = p.colModel[j].name;
+ switch (cmName) {
+ case "rn":
+ rowData.push(addRowNum(j, i, p.page, p.rowNum));
+ break;
+ case "cb":
+ rowData.push(addMulti(idr, j, i, selr, rd));
+ break;
+ case "subgrid":
+ rowData.push($j.addSubGridCell.call($self, j, i + rcnt, idr, rd));
+ break;
+ default:
+ rowData.push(addCell(idr, rd[cmName], j, i + rcnt, cells, rd));
+ }
+ }
+ if (p.grouping && $j.groupingPrepare && !p.groupingView._locgr) {
+ $j.groupingPrepare.call($self, rd, i);
+ if ($.isFunction(p.groupingView.groupCollapse)) {
+ hiderow = p.groupingView.groupCollapse.call(self, {
+ group: p.groupingView.groups[p.groupingView.groups.length - 1],
+ rowid: idr,
+ data: rd
+ });
+ }
+ }
+ rowData[iStartTrTag] = self.constructTr(idr, hiderow, cn1, rd, cells, selr);
+ rowData.push("");
+ p.rowIndexes[idr] = rowIndex;
+ rowIndex++;
+ //TODO: fix p.rowIndexes in case of usage grouping.
+ if (p.grouping) {
+ // we save the rowData in the array grpdata first.
+ // grpdata will collect HTML fragments of all rows of data
+ // of the current group. Later we call groupingRender, which
+ // will insert additional grouping row and concatinate all
+ // the HTML fragments of all rows of the group.
+ grpdata.push(rowData);
+ rowData = []; // the data for rendering are moved in grpdata
+ }
+ if (rowData.length > p.maxItemsToJoin) {
+ rowData = [rowData.join("")];
+ }
+ }
+ if (p.grouping && $j.groupingRender) {
+ if (readAllInputData) {
+ p.groupingView._locgr = true;
+ }
+ rowData = [$j.groupingRender.call($self, grpdata, rn)];
+ jgrid.clearArray(grpdata); //grpdata = null;
+ }
+ return rowData;
+ },
+ fillSelectOptions: function (elem, value, sep, delim, isMultiple, valuesToSelect) {
+ var i, so, sv, ov, optionInfo, optionInfos = [], isSelected, key, ovm,
+ isNoFilterValueExist = false,
+ mapFunc = function (n, ii) { if (ii > 0) { return n; } };
+
+ if (!value) { return; }
+ if (typeof value === "function") {
+ value = value();
+ }
+
+ if (typeof value === "string") {
+ so = value.split(delim);
+ for (i = 0; i < so.length; i++) {
+ sv = so[i].split(sep);
+ if (sv.length > 2) {
+ sv[1] = $.map(sv, mapFunc).join(sep);
+ }
+ optionInfos.push({
+ value: sv[0],
+ innerHtml: sv[1],
+ selectValue: $.trim(sv[0]),
+ selectText: $.trim(sv[1]),
+ selected: false
+ });
+ if (sv[0] === "") {
+ isNoFilterValueExist = true;
+ }
+ }
+ } else if (typeof value === "object") {
+ for (key in value) {
+ if (value.hasOwnProperty(key)) {
+ optionInfos.push({
+ value: key,
+ innerHtml: value[key],
+ selectValue: $.trim(key),
+ selectText: $.trim(value[key]),
+ selected: false
+ });
+ }
+ if (key === "") {
+ isNoFilterValueExist = true;
+ }
+ }
+ }
+
+ if (typeof valuesToSelect === "string") {
+ ovm = isMultiple ?
+ $.map(valuesToSelect.split(","), function (n) { return $.trim(n); }) :
+ [$.trim(valuesToSelect)];
+
+ valuesToSelect = $.trim(valuesToSelect);
+
+ // mark selection
+ // 1) first by value
+ for (i = 0; i < optionInfos.length; i++) {
+ optionInfo = optionInfos[i];
+ if (!isMultiple && optionInfo.selectValue === valuesToSelect) {
+ optionInfo.selected = true;
+ isSelected = true;
+ }
+ if (isMultiple && $.inArray(optionInfo.selectValue, ovm) > -1) {
+ optionInfo.selected = true;
+ isSelected = true;
+ }
+ }
+
+ // 2) when no selection by value, then by text
+ if (!isSelected) {
+ for (i = 0; i < optionInfos.length; i++) {
+ optionInfo = optionInfos[i];
+ if (!isMultiple && optionInfo.selectText === valuesToSelect) {
+ optionInfo.selected = true;
+ }
+ if (isMultiple && $.inArray(optionInfo.selectText, ovm) > -1) {
+ optionInfo.selected = true;
+ }
+ }
+ }
+ }
+
+ for (i = 0; i < optionInfos.length; i++) {
+ optionInfo = optionInfos[i];
+ ov = document.createElement("option");
+ ov.value = optionInfo.value;
+ ov.innerHTML = optionInfo.innerHtml;
+ if (optionInfo.selected) {
+ ov.selected = true;
+ }
+ elem.appendChild(ov);
+ }
+
+ return isNoFilterValueExist;
+ },
+ getMethod: function (name) {
+ // this should be $.jgrid object
+ return this.getAccessor($.fn.jqGrid, name);
+ },
+ extend: function (methods) {
+ $.extend($.fn.jqGrid, methods);
+ if (!this.no_legacy_api) {
+ $.fn.extend(methods);
+ }
+ }
+ });
+ var clearArray = jgrid.clearArray, jqID = jgrid.jqID,
+ getGridComponentIdSelector = jgrid.getGridComponentIdSelector, getGridComponentId = jgrid.getGridComponentId,
+ getGridComponent = jgrid.getGridComponent, stripPref = jgrid.stripPref, randId = jgrid.randId,
+ getAccessor = jgrid.getAccessor, convertOnSaveLocally = jgrid.convertOnSaveLocally,
+ stripHtml = jgrid.stripHtml, htmlEncode = jgrid.htmlEncode, htmlDecode = jgrid.htmlDecode,
+ mergeCssClasses = jgrid.mergeCssClasses, hasOneFromClasses = jgrid.hasOneFromClasses,
+ feedback = function () {
+ // short form of $.jgrid.feedback to save usage this.p as the first parameter
+ var args = $.makeArray(arguments);
+ args.unshift("");
+ args.unshift("");
+ args.unshift(this.p);
+ return jgrid.feedback.apply(this, args);
+ };
+
+ /**
+ * @param {(string|Object)} pin
+ */
+ $.fn.jqGrid = function (pin) {
+ var $j = $.fn.jqGrid, fn;
+ if (typeof pin === "string") {
+ fn = $j[pin];
+ if (!fn) {
+ throw ("jqGrid - No such method: " + pin);
+ }
+ return fn.apply(this, $.makeArray(arguments).slice(1));
+ }
+ return this.each(function () {
+ if (this.grid) { return; }
+ // TODO: verify that pin.locale exists in locales. If it's not exist then change it to
+ // en-US or some other which exist
+ var ts = this, localData, localDataStr, $self0 = $(ts),
+ isFunction = $.isFunction, isArray = $.isArray, extend = $.extend, inArray = $.inArray,
+ trim = $.trim, each = $.each, setSelection = $j.setSelection, getGridRes = $j.getGridRes,
+ fatalErrorFunction = isFunction(defaults.fatalError) ? defaults.fatalError : alert,
+ locale = pin.locale || defaults.locale || "en-US",
+ direction = locales[locale] != null && typeof locales[locale].isRTL === "boolean" ? (locales[locale].isRTL ? "rtl" : "ltr") : "ltr",
+ iconSet = pin.iconSet || defaults.iconSet || ((pin.guiStyle || defaults.guiStyle) === "bootstrap" || (pin.guiStyle || defaults.guiStyle) === "bootstrapPrimary" ? "glyph" : "jQueryUI"),
+ guiStyle = pin.guiStyle || defaults.guiStyle || "jQueryUI",
+ getIcon = function (path) {
+ //return jgrid.getIconRes(iconSet, path);
+ return $j.getIconRes.call(ts, path);
+ },
+ getGuiStyles = function (path, jqClasses) {
+ return $self0.jqGrid("getGuiStyles", path, jqClasses);
+ },
+ stdLoadError = function (jqXHR, textStatus, errorThrown) {
+ if (textStatus !== "abort" && errorThrown !== "abort") {
+ var contentType = jqXHR.getResponseHeader ("Content-Type"),
+ message = jqXHR.responseText || "",
+ processHtmlError = function (msg) {
+ var div = document.createElement("div"), scripts, i, bodyMatch;
+ // get body only and strip all scripts
+ bodyMatch = /]*>([\s\S]*)<\/body\s*>/gim.exec(msg);
+ div.innerHTML = bodyMatch != null && bodyMatch.length === 2 ?
+ bodyMatch[1] : msg;
+ scripts = div.getElementsByTagName("script");
+ i = scripts.length;
+ while (i--) {
+ scripts[i].parentNode.removeChild(scripts[i]);
+ }
+ // strip html headers and get the body only
+ msg = div.innerHTML;
+ try {
+ // remove HTML, if it has no text
+ if ($.trim($(msg).text()) === "") {
+ msg = "";
+ }
+ }
+ catch (ignore) {}
+ return msg;
+ },
+ processJsonError = function (msg) {
+ try {
+ var errorInfo = $.parseJSON(msg), errorMessages = [], errorProp;
+ for (errorProp in errorInfo) {
+ if (errorInfo.hasOwnProperty(errorProp) && errorProp !== "StackTrace") {
+ errorMessages.push(errorProp + ": " + errorInfo[errorProp]);
+ }
+ }
+ msg = errorMessages.join("
"),
+ isMSIE = jgrid.msie, dir;
+ p.direction = trim(p.direction.toLowerCase());
+ if (inArray(p.direction, ["ltr", "rtl"]) === -1) { p.direction = "ltr"; }
+ dir = p.direction;
+
+ $(gv).insertBefore(ts);
+ $self0.removeClass("scroll").appendTo(gv);
+ var eg = $("
");
+ $(eg).attr({ "id": p.gBoxId, "dir": dir }).insertBefore(gv);
+ $(gv).attr("id", p.gViewId).appendTo(eg);
+ $("
").insertBefore(gv);
+ $("" + getDef("loadtext") + "
").insertBefore(gv);
+ $self0.attr({ "role": "presentation", "aria-labelledby": "gbox_" + ts.id });
+ var sortkeys = ["shiftKey", "altKey", "ctrlKey"],
+ // for reading of array of items from the input data it's required to know the
+ // mapping of input items to the column names (colModel[iCol].name items).
+ // The function normalizeRemapColumns converts p.remapColumns to p.cmNamesInputOrder and fills
+ // p.cmNamesInputOrder with the names colModel items.
+ // The function should be called only if no p.cmNamesInputOrder is specified
+ normalizeRemapColumns = function () {
+ // offset is the number of columns in colModel which should be skipped in calculation of the mapping
+ // offset is the number of columns from the list "rn", "cb", "subgrid".
+ // The index 0 in the p.remapColumns means the first column after the "rn", "cb", "subgrid"
+ var remapColumns = p.remapColumns, colModel = p.colModel, nCol = colModel.length, cmNames = [], i, remappedCmNames,
+ name;
+ for (i = 0; i < nCol; i++) {
+ name = colModel[i].name;
+ if (inArray(name, p.reservedColumnNames) < 0) {
+ cmNames.push(name);
+ }
+ }
+
+ // it's important to remark that the numbers in remapColumns or in
+ // jsonReder, localReader, xmlReader are based on the position of column
+ // in colModel BEFORE adding columns "rn", "cb", "subgrid"
+ if (remapColumns != null) {
+ // now we should remap items in cmNames corresponds to the indexes from p.remapColumns array
+ remappedCmNames = cmNames.slice(); // make copy of cmNames array
+ for (i = 0; i < remapColumns.length; i++) {
+ cmNames[i] = remappedCmNames[remapColumns[i]];
+ }
+ }
+ p.cmNamesInputOrder = cmNames;
+ },
+ stripGridPrefix = function (rowId) {
+ return stripPref(p.idPrefix, rowId);
+ },
+ formatCol = function (pos, rowInd, tv, rawObject, rowId, rdata) {
+ var cm = p.colModel[pos], cellAttrFunc, cellValue = tv, rPrefix,
+ result, classes = cm.classes,
+ styleValue = cm.align ? "text-align:" + cm.align + ";" : "",
+ attrStr, matches, value, tilteValue,
+ encodeAttr = function (v) {
+ return typeof v === "string" ? v.replace(/\'/g, "'") : v;
+ },
+ rest = " aria-describedby='" + p.id + "_" + cm.name + "'";
+ if (cm.hidden === true) { styleValue += "display:none;"; }
+ if (rowInd === 0) {
+ styleValue += "width: " + grid.headers[pos].width + "px;";
+ } else if (isFunction(cm.cellattr) || (typeof cm.cellattr === "string" && jgrid.cellattr != null && isFunction(jgrid.cellattr[cm.cellattr]))) {
+ cellAttrFunc = isFunction(cm.cellattr) ? cm.cellattr : jgrid.cellattr[cm.cellattr];
+ if (p.useUnformattedDataForCellAttr && rdata != null) {
+ cellValue = rdata[cm.name];
+ } else if (cm.autoResizable) {
+ // see https://github.com/free-jqgrid/jqGrid/issues/74#issuecomment-107675796
+ // we will cut formatted string like "193,81 "
+ // to substring "193,81". The formatting (comma, point, dollar and so on) still stay.
+ rPrefix = "";
+ cellValue = tv.substring(rPrefix.length, tv.length - " ".length);
+ }
+ attrStr = cellAttrFunc.call(ts, rowId, cellValue, rawObject, cm, rdata);
+ if (typeof attrStr === "string") {
+ // ??? probably one can create object with properties from the attrStr
+ // and then to use one common function with constructTr to combin the default
+ // properties with the properties used in cellattr and rowattr.
+ // Probably one could use $.extend with the most attributes. The exception are
+ // only class and style attributes which hold multi-values with " " or ";" as separator
+ attrStr = attrStr.replace(/\n/g, "
");
+ while (true) {
+ // we have to use ? in the construction ([^\2]*?) to have non-greedy (lazy, minimal) matching
+ // so that we will find the FIRST closing quote instead of default the LAST matching.
+
+ // TODO: more common regex for the attribute name.
+ // See http://www.w3.org/TR/html-markup/syntax.html#syntax-attributes:
+ // Attribute names must consist of one or more characters other than the space
+ // characters, U+0000 NULL, """, "'", ">", "/", "=", the control characters,
+ // and any characters that are not defined by Unicode.
+ // An important example is attribute name with "-" in the middle: "data-sometext"
+ // An important example is attribute name with "-" in the middle: "data-sometext"
+ matches = /^\s*(\w+[\w|\-]*)\s*=\s*([\"|\'])(.*?)\2(.*)/.exec(attrStr);
+ if (matches === null || matches.length < 5) {
+ if (!tilteValue && cm.title) {
+ tilteValue = cellValue;
+ }
+ return rest + " style='" + encodeAttr(styleValue) + "'" +
+ (classes ? " class='" + encodeAttr(classes) + "'" : "") +
+ (tilteValue ? " title='" + encodeAttr(tilteValue) + "'" : "");
+ }
+ value = matches[3];
+ attrStr = matches[4];
+ switch (matches[1].toLowerCase()) { // attribute name
+ case "class":
+ // if some special characters are inside of class value there MUST be escaped
+ // so we can use any quote characters (' or ") around the call value.
+ // So we don't need to save quote used in class attribute
+ if (classes) {
+ classes += " " + value;
+ } else {
+ classes = value;
+ }
+ break;
+ case "title":
+ //quotedTilteValue = quote + value + quote;
+ tilteValue = value;
+ break;
+ case "style":
+ styleValue += value;
+ break;
+ default:
+ // matches[2] is quote
+ rest += " " + matches[1] + "=" + matches[2] + value + matches[2];
+ break;
+ }
+ }
+ }
+ }
+ result = styleValue !== "" ? "style='" + styleValue + "'" : "";
+ result += (classes !== undefined ? (" class='" + classes + "'") : "") + ((cm.title && cellValue) ? (" title='" + stripHtml(tv).replace(/\'/g, "'") + "'") : "");
+ result += rest;
+ return result;
+ },
+ cellVal = function (val) {
+ return val == null || val === "" ? " " : (p.autoencode ? htmlEncode(val) : String(val));
+ },
+ normalizeTreeGridProperties = function (ldat) {
+ var treeReader = p.treeReader,
+ loaded = treeReader.loaded,
+ isLeaf = treeReader.leaf_field,
+ expanded = treeReader.expanded_field,
+ getBool = function (val) {
+ return val === true || val === "true" || val === "1";
+ };
+ if (p.treeGridModel === "nested" && !ldat[isLeaf]) {
+ var lft = parseInt(ldat[treeReader.left_field], 10),
+ rgt = parseInt(ldat[treeReader.right_field], 10);
+ ldat[isLeaf] = (rgt === lft + 1) ? true : false;
+ }
+ if (ldat[loaded] !== undefined) {
+ ldat[loaded] = getBool(ldat[loaded]);
+ }
+ ldat[isLeaf] = getBool(ldat[isLeaf]);
+ ldat[expanded] = getBool(ldat[expanded]);
+ // the next line is suspected. The local data which missing loaded property
+ // can be be changed to have expanded=false
+ // we comment it.
+ //ldat[expanded] = ldat[expanded] && (ldat[loaded] || ldat[loaded] === undefined);
+ },
+ formatter = function (rowId, cellval, colpos, rwdat, act, rdata) {
+ var cm = p.colModel[colpos], v;
+ if (cm.formatter !== undefined) {
+ rowId = String(p.idPrefix) !== "" ? stripGridPrefix(rowId) : rowId;
+ var opts = { rowId: rowId, colModel: cm, gid: p.id, pos: colpos, rowData: rdata || rwdat };
+ if (isFunction(cm.cellBuilder)) {
+ v = cm.cellBuilder.call(ts, cellval, opts, rwdat, act);
+ } else if (isFunction(cm.formatter)) {
+ v = cm.formatter.call(ts, cellval, opts, rwdat, act);
+ } else if ($.fmatter) {
+ v = $.fn.fmatter.call(ts, cm.formatter, cellval, opts, rwdat, act);
+ } else {
+ v = cellVal(cellval);
+ }
+ } else {
+ v = cellVal(cellval);
+ }
+ v = cm.autoResizable && cm.formatter !== "actions" ? "" + v + " " : v;
+ if (p.treeGrid && act !== "edit" && ((p.ExpandColumn == null && colpos === 0) || (p.ExpandColumn === cm.name))) {
+ if (rdata == null) { rdata = p.data[p._index[rowId]]; }
+ var curLevel = parseInt(rdata[p.treeReader.level_field] || 0, 10), levelOffset = 18,
+ rootLevel = parseInt(p.tree_root_level, 10),
+ lftpos = rootLevel === 0 ? curLevel : curLevel - 1,
+ isLeaf = rdata[p.treeReader.leaf_field],
+ isExpanded = rdata[p.treeReader.expanded_field],
+ icon = rdata[p.treeReader.icon_field],
+ iconClass = isLeaf ?
+ ((icon != null && icon !== "") ? icon : p.treeIcons.leaf) + " tree-leaf" :
+ (isExpanded ? p.treeIcons.minus + " tree-minus" : p.treeIcons.plus + " tree-plus");
+ //normalizeTreeGridProperties(rdata); // ??? don't needed more probably
+ if (!isLeaf && icon && typeof icon === "string") {
+ var icons = icon.split(",");
+ if (icons.length === 2) {
+ iconClass = isExpanded ? icons[0] : icons [1];
+ }
+ }
+
+ v = "" +
+ "" +
+ v + " ";
+ }
+ return v;
+ },
+ emptyRows = function (scroll, locdata) {
+ var self = this, bDiv = grid.bDiv,
+ frozenTable = grid.fbDiv != null ?
+ grid.fbDiv.children(".ui-jqgrid-btable")[0] : null,
+ removeRows = function (table) {
+ if (!table) { return; }
+ var tableRows = table.rows, firstrow = tableRows[0];
+ if (p.deepempty) {
+ if (tableRows) { $(tableRows).slice(1).remove(); }
+ } else if (p.quickEmpty) {
+ if (p.quickEmpty === "quickest") {
+ table.replaceChild(document.createElement("tbody"), table.tBodies[0]);
+ table.firstChild.appendChild(firstrow);
+ } else {
+ while (tableRows.length > 1) { // skip deliting of the first row
+ table.deleteRow(tableRows.length - 1);
+ }
+ }
+ } else {
+ $(table.firstChild).empty().append(firstrow);
+ }
+ };
+ $(self).off(".jqGridFormatter");
+ removeRows(self);
+ removeRows(frozenTable);
+ if (scroll && p.scroll) {
+ $(bDiv.firstChild).css({ height: "auto" });
+ $(bDiv.firstChild.firstChild).css({ height: 0, display: "none" });
+ if (bDiv.scrollTop !== 0) {
+ bDiv.scrollTop = 0;
+ }
+ }
+ if (locdata === true && p.treeGrid) {
+ clearArray(p.data); //p.data = [];
+ clearArray(p.lastSelectedData); //p.lastSelectedData = [];
+ p._index = {};
+ p.dataIndexById = {};
+ p.indexByColumnData = {};
+ }
+ p.rowIndexes = {};
+ p.iRow = -1;
+ p.iCol = -1;
+ //$(self.grid.headers).each(function () { $(this.el).removeData("autoResized"); });
+ },
+ addItemDataToColumnIndex = function (rd, id) {
+ var cmName, v;
+ for (cmName in p.indexByColumnData) {
+ if (p.indexByColumnData.hasOwnProperty(cmName)) {
+ v = rd[cmName];
+ if (rd.hasOwnProperty(cmName) && v !== undefined && v !== "") {
+ // rd[cmName] is the value, which need be saved in p.indexByColumnData[cmName]
+ if (p.ignoreCase) {
+ v = String(v).toLowerCase();
+ }
+ if (p.indexByColumnData[cmName][v] === undefined) {
+ p.indexByColumnData[cmName][v] = {};
+ }
+ p.indexByColumnData[cmName][v][id] = rd[cmName];
+
+ if (p.dataIndexById[id] === undefined) {
+ p.dataIndexById[id] = {};
+ }
+ if (p.dataIndexById[id][cmName] === undefined) {
+ p.dataIndexById[id][cmName] = {};
+ }
+ p.dataIndexById[id][cmName][v] = p.indexByColumnData[cmName][v];
+ }
+ }
+ }
+ },
+ removeItemDataFromColumnIndex = function (id) {
+ var cmName, columnIndex, v, index = p.dataIndexById[id];
+ if (index == null) {
+ return;
+ }
+ for (cmName in index) {
+ if (index.hasOwnProperty(cmName)) {
+ columnIndex = index[cmName];
+ for (v in columnIndex) {
+ if (columnIndex.hasOwnProperty(v)) {
+ delete p.indexByColumnData[cmName][v][id];
+ if ($.isEmptyObject(p.indexByColumnData[cmName][v])) {
+ delete p.indexByColumnData[cmName][v];
+ }
+ }
+ }
+ }
+ }
+ delete p.dataIndexById[id];
+ },
+ normalizeData = function () {
+ var data = p.data, dataLength = data.length, i, cur, cells, idName, idIndex, v, rd, id,
+ localReader = p.localReader, additionalProperties = p.additionalProperties,
+ cellName = localReader.cell, cmName, isArrayCells, addProp, info,
+ arrayReaderInfos = p.arrayReaderInfos;
+
+ if (p.datatype !== "local" || localReader.repeatitems !== true) {
+ if (p.treeGrid) {
+ for (i = 0; i < dataLength; i++) {
+ normalizeTreeGridProperties(data[i]);
+ }
+ }
+ return; // nothing to do
+ }
+
+ idName = p.keyName === false ?
+ (isFunction(localReader.id) ? localReader.id.call(ts, data) : localReader.id) :
+ p.keyName;
+ if (!isNaN(idName)) {
+ idIndex = Number(idName);
+ /*for (cmName in arrayReaderInfos) {
+ if (arrayReaderInfos.hasOwnProperty(cmName)) {
+ info = arrayReaderInfos[cmName];
+ if (info.order === idIndex) {
+ idName = info.name;
+ break;
+ }
+ }
+ }*/
+ } else if (!isFunction(idName)) {
+ if (p.arrayReaderInfos[idName] != null) {
+ idIndex = p.arrayReaderInfos[idName].order;
+ }
+ }
+
+ for (i = 0; i < dataLength; i++) {
+ cur = data[i];
+ cells = cellName ? getAccessor(cur, cellName) || cur : cur;
+ isArrayCells = isArray(cells);
+
+ rd = {};
+ for (cmName in arrayReaderInfos) {
+ if (arrayReaderInfos.hasOwnProperty(cmName)) {
+ info = arrayReaderInfos[cmName];
+ v = getAccessor(cells, isArrayCells ? info.order : info.name);
+ if (info.type === 1) { // additional property
+ addProp = additionalProperties[info.index];
+ if (addProp != null && isFunction(addProp.convert)) {
+ v = addProp.convert(v, cells);
+ }
+ }
+ if (v !== undefined) {
+ rd[cmName] = v;
+ }
+ }
+ }
+
+ // read id.
+ if (rd[idName] !== undefined) {
+ // in case of p.keyName or if there exist column with the same id name
+ // probably one should test only for rd[p.keyName] !== undefined
+ // and get rd[p.keyName] below, but the probability that the user
+ // wanted to use the column rd[idName] as the rowid seemd me
+ // higher as the opposite case.
+
+ // the id should be already read in p.keyName column.
+ // One need generate id only if the input data had no id
+ id = rd[idName] !== undefined ? rd[idName] : randId(); //id = br + i;
+ } else {
+ id = getAccessor(cur, isArray(cur) ? idIndex : idName);
+ if (id === undefined) {
+ id = getAccessor(cells, isArray(cells) ? idIndex : idName);
+ }
+ if (id === undefined) {
+ id = randId(); //id = br + i;
+ }
+ }
+ id = String(id);
+ rd[localReader.id] = id; //p.idPrefix + id;
+
+ // the next two line are the most important!
+ // one should consider to remove true parameter to improve the performance !!!
+ if (p.treeGrid) { normalizeTreeGridProperties(rd); }
+ extend(data[i], rd); // extend(true, data[i], rd);
+ }
+ },
+ refreshIndex = function () {
+ var datalen = p.data.length, idname, i, val, item;
+
+ if (p.keyName === false || (p.loadonce && p.dataTypeOrg)) {
+ idname = p.localReader.id;
+ } else {
+ idname = p.keyName;
+ }
+ p._index = {};
+ p.dataIndexById = {};
+ p.indexByColumnData = buildEmptyIndexedColumnMap();
+ for (i = 0; i < datalen; i++) {
+ item = p.data[i];
+ val = getAccessor(item, idname);
+ if (val === undefined) {
+ val = String(randId()); //String(i + 1);
+ if (item[idname] === undefined) {
+ item[idname] = val;
+ }
+ }
+ p._index[val] = i;
+ addItemDataToColumnIndex.call(this, item, val);
+ }
+ },
+ constructTr = function (id, hide, altClass, rd, cur, selected) {
+ var tabindex = "-1", restAttr = "", attrName, style = hide ? "display:none;" : "", self = this,
+ classes = getGuiStyles("gridRow", "jqgrow ui-row-" + p.direction) + (altClass ? " " + altClass : "") + (selected ? " " + getGuiStyles("states.select") : ""),
+ rowAttrObj = $(self).triggerHandler("jqGridRowAttr", [rd, cur, id]);
+ if (typeof rowAttrObj !== "object") {
+ rowAttrObj = isFunction(p.rowattr) ? p.rowattr.call(self, rd, cur, id) :
+ (typeof p.rowattr === "string" && jgrid.rowattr != null && isFunction(jgrid.rowattr[p.rowattr]) ?
+ jgrid.rowattr[p.rowattr].call(self, rd, cur, id) : {});
+ }
+ if (rowAttrObj != null && !$.isEmptyObject(rowAttrObj)) {
+ if (rowAttrObj.hasOwnProperty("id")) {
+ id = rowAttrObj.id;
+ delete rowAttrObj.id;
+ }
+ if (rowAttrObj.hasOwnProperty("tabindex")) {
+ tabindex = rowAttrObj.tabindex;
+ delete rowAttrObj.tabindex;
+ }
+ if (rowAttrObj.hasOwnProperty("style")) {
+ style += rowAttrObj.style;
+ delete rowAttrObj.style;
+ }
+ if (rowAttrObj.hasOwnProperty("class")) {
+ classes += " " + rowAttrObj["class"];
+ delete rowAttrObj["class"];
+ }
+ // don't allow to change role attribute
+ try { delete rowAttrObj.role; } catch (ignore) { }
+ for (attrName in rowAttrObj) {
+ if (rowAttrObj.hasOwnProperty(attrName)) {
+ restAttr += " " + attrName + "=" + rowAttrObj[attrName];
+ }
+ }
+ }
+ if (p.treeGrid) {
+ if (parseInt(rd[p.treeReader.level_field], 10) !== parseInt(p.tree_root_level, 10)) {
+ var pn = $j.getNodeParent.call($(this), rd),
+ expan = pn && pn.hasOwnProperty(p.treeReader.expanded_field) ?
+ pn[p.treeReader.expanded_field] : true;
+ if (!expan && !hide) {
+ // TODO: append ";" to style if required
+ style += "display:none;";
+ }
+ }
+ }
+ return "";
+ },
+ finalizationFormatters = function () {
+ var i, formatName, fmatter = $.fn.fmatter;
+ for (i = 0; i < p.colModel.length; i++) {
+ formatName = p.colModel[i].formatter;
+ if (typeof formatName === "string" && fmatter != null &&
+ isFunction(fmatter[formatName]) && isFunction(fmatter[formatName].pageFinalization)) {
+ fmatter[formatName].pageFinalization.call(this, i);
+ }
+ }
+ },
+ fillOrClearCellBuilder = function (clear, act) {
+ var i, cm, colModel = p.colModel, n = colModel.length, opt,
+ autoencodeCellBuilder = function (v) {
+ return v == null || v === "" ? " " : htmlEncode(v);
+ },
+ simpleCellBuilder = function (v) {
+ return v == null || v === "" ? " " : String(v);
+ };
+ for (i = 0; i < n; i++) {
+ cm = colModel[i];
+ cm.cellBuilder = null;
+ if (!clear) {
+ opt = { colModel: cm, gid: p.id, pos: i };
+ if (cm.formatter === undefined) {
+ cm.cellBuilder = p.autoencode ? autoencodeCellBuilder : simpleCellBuilder;
+ } else if (typeof cm.formatter === "string" && $.fn.fmatter != null && isFunction($.fn.fmatter.getCellBuilder)) {
+ cm.cellBuilder = $.fn.fmatter.getCellBuilder.call(ts, cm.formatter, opt, act || "add");
+ } else if (isFunction(cm.getCellBuilder)) {
+ cm.cellBuilder = cm.getCellBuilder.call(ts, opt, act || "add");
+ }
+ }
+ }
+ },
+ readInput = function (data, rcnt, more, adjust) {
+ var self = this, $self = $(self), startReq = new Date(), datatype = p.datatype,
+ // readAllInputData shows that one should read ALL input items, not only the current page of data
+ readAllInputData = (datatype !== "local" && p.loadonce) || datatype === "xmlstring" || datatype === "jsonstring",
+ isXML = (datatype === "xmlstring" || datatype === "xml") && $.isXMLDoc(data),
+ locid = "_id_", dataReader = p.localReader, fieldReader = getAccessor;
+
+ if (data) {
+ if (datatype === "xml" && !isXML) {
+ return;
+ }
+ if (p.treeANode === -1 && !p.scroll) {
+ grid.emptyRows.call(self, false, true);
+ rcnt = 1;
+ } else {
+ rcnt = rcnt > 1 ? rcnt : 1;
+ }
+ } else {
+ // in case of usage TreeGrid for example
+ return;
+ }
+
+ if (readAllInputData) {
+ clearArray(p.data); //p.data = [];
+ clearArray(p.lastSelectedData); //p.lastSelectedData = [];
+ p._index = {};
+ if (p.grouping && p.groupingView != null) {
+ p.groupingView.groups = [];
+ p.groupingView._locgr = false;
+ }
+ p.localReader.id = locid; // consider to place the statement in if (p.treeGrid) {...}
+ }
+ p.reccount = 0;
+ switch (datatype) {
+ case "xml":
+ case "xmlstring":
+ dataReader = p.xmlReader;
+ fieldReader = jgrid.getXmlData;
+ break;
+ case "json":
+ case "jsonp":
+ case "jsonstring":
+ dataReader = p.jsonReader;
+ break;
+ default:
+ break;
+ }
+
+ var i, cells, len, drows, idName, idIndex, rd = {}, idr,
+ colModel = p.colModel, nCol = colModel.length, cmName,
+ iChild, children, nChildren, child,
+ // TODO: consider to introduce preloadedAttributes in the same way
+ // like we use to preloadedNodes below and to cache .attributes[i]
+ // in the same way like one cache .childNodes[i].
+ // One should measure the performance, to find out whether
+ // such caching will improve the performance.
+ arrayReaderInfos = p.arrayReaderInfos, info, preloadedNodes = {},
+ attrReader = function (nodeName) {
+ return function (obj) {
+ var attrValue = obj != null && isFunction(obj.getAttribute) ? obj.getAttribute(nodeName) : null;
+ return attrValue !== null ? attrValue : undefined;
+ };
+ },
+ nodeReader = function (nodeName) {
+ return function () {
+ // commented code which used getElementsByTagName works
+ // good in new web browsers (Chrome, Firefox, Safari),
+ // but it is slowly in IE10 and especially in IE8.
+ // So we use the code which is very good for all web browsers
+ /*var elem = obj.getElementsByTagName(nodeName)[0], childNodes;
+ if (elem != null) {
+ childNodes = elem.childNodes;
+ return childNodes.length > 0 ? childNodes[0].nodeValue : undefined;
+ }
+ return undefined;*/
+ var elem = preloadedNodes[nodeName], childNodes;
+ if (elem == null) { return undefined; }
+ childNodes = elem.childNodes;
+ return childNodes.length > 0 ? childNodes[0].nodeValue : undefined;
+ };
+ };
+
+ p.page = intNum(fieldReader(data, dataReader.page), p.page);
+ p.lastpage = intNum(fieldReader(data, dataReader.total), 1);
+ p.records = intNum(fieldReader(data, dataReader.records));
+
+ if (isFunction(dataReader.userdata)) {
+ p.userData = dataReader.userdata.call(self, data) || {};
+ } else if (isXML) {
+ fieldReader(data, dataReader.userdata, true)
+ .each(function () {
+ p.userData[this.getAttribute("name")] = $(this).text();
+ });
+ } else {
+ p.userData = fieldReader(data, dataReader.userdata) || {};
+ }
+
+ // fill colReader and
+ fillOrClearCellBuilder();
+ var colReader = {}, isArrayCells, v, addProp, items,
+ additionalProperties = p.additionalProperties,
+ setSimpleColReaderIfPossible = function (propName, nameReaderOrAddProp) {
+ if (isXML && typeof nameReaderOrAddProp === "string") {
+ if (/^\w+$/.test(nameReaderOrAddProp)) {
+ colReader[propName] = nodeReader(nameReaderOrAddProp);
+ } else if (/^\[\w+\]$/.test(nameReaderOrAddProp)) {
+ colReader[propName] = attrReader(nameReaderOrAddProp.substring(1, nameReaderOrAddProp.length - 1));
+ }
+ }
+ },
+ colReaderFilling = function (colOrAddProp) {
+ var colOrAddPropName = colOrAddProp.name,
+ nameReader = isXML ?
+ colOrAddProp.xmlmap || colOrAddPropName :
+ (datatype === "local" && !p.dataTypeOrg) || datatype === "jsonstring" || datatype === "json" || datatype === "jsonp" ? colOrAddProp.jsonmap || colOrAddPropName : colOrAddPropName;
+
+ if (p.keyName !== false && colOrAddProp.key === true) {
+ p.keyName = colOrAddPropName; // TODO: replace nameReader to colOrAddPropName if we don't will read it at the second time
+ }
+ if (typeof nameReader === "string" || isFunction(nameReader)) {
+ colReader[colOrAddPropName] = nameReader;
+ }
+ if (!isFunction(nameReader)) {
+ setSimpleColReaderIfPossible(colOrAddPropName, nameReader);
+ }
+ };
+ for (i = 0; i < nCol; i++) {
+ colReaderFilling(colModel[i]);
+ }
+ nCol = additionalProperties.length;
+ for (i = 0; i < nCol; i++) {
+ addProp = additionalProperties[i];
+
+ if (typeof addProp === "object" && addProp != null) {
+ colReaderFilling(addProp);
+ } else {
+ setSimpleColReaderIfPossible(addProp, addProp);
+ }
+ }
+ // TODO: Consider to allow to specify key:true property in additionalProperties
+ // in the case the item of additionalProperties should looks not like
+ // "myProp" and not like {name: "myProp", convert: function (data) {...}} used in TreeGrid,
+ // but in more common form {name: "myProp", key:true, convert: function (data) {...}}
+
+ // prepare to read id of data items
+ // if p.keyName !== false it contains the name of the column or the nameReader functoin (jsonmap or xmlmap)
+ // in the case the reading of id is simple and one DON'T NEED TO READ IT AT ALL
+ // because it will be already read during reading of the columns
+ idName = p.keyName === false ?
+ (isFunction(dataReader.id) ? dataReader.id.call(self, data) : dataReader.id) :
+ p.keyName;
+
+ if (!isNaN(idName)) {
+ idIndex = Number(idName);
+ } else if (!isFunction(idName)) {
+ if (arrayReaderInfos[idName]) {
+ idIndex = arrayReaderInfos[idName].order;
+ }
+ if (isXML) {
+ if (typeof idName === "string" && /^\[\w+\]$/.test(idName)) {
+ idName = attrReader(idName.substring(1, idName.length - 1));
+ } else if (typeof idName === "string" && /^\w+$/.test(idName)) {
+ idName = nodeReader(idName);
+ }
+ }
+ }
+
+ // get array of items from the input data
+ drows = fieldReader(data, dataReader.root, true);
+ if (dataReader.row) {
+ if (drows.length === 1 && typeof dataReader.row === "string" && /^\w+$/.test(dataReader.row)) {
+ items = [];
+ children = drows[0].childNodes;
+ nChildren = children.length;
+ for (iChild = 0; iChild < nChildren; iChild++) {
+ child = children[iChild];
+ if (child.nodeType === 1 && child.nodeName === dataReader.row) {
+ items.push(child);
+ }
+ }
+ drows = items;
+ } else {
+ drows = fieldReader(drows, dataReader.row, true); // || [];
+ }
+ }
+ if (drows == null && isArray(data)) { drows = data; }
+ if (!drows) { drows = []; }
+ len = drows.length;
+ if (len > 0 && p.page <= 0) { p.page = 1; }
+
+ var rn = parseInt(p.rowNum, 10); // br = p.scroll ? randId() : 1
+ if (adjust) { rn *= adjust + 1; }
+
+ // The first loop (from 0 till len) read ALL data and saves it in array
+ var cellsToDisplay = [], ids = [], id, cur;
+ items = [];
+ for (i = 0; i < len; i++) {
+ cur = drows[i];
+ cells = dataReader.repeatitems && dataReader.cell ? fieldReader(cur, dataReader.cell, true) || cur : cur;
+ isArrayCells = dataReader.repeatitems && (isXML || isArray(cells));
+
+ // the first step: reading the input data from the current item
+ rd = {}; // require to prevent modification of items previously placed in p.data
+
+ preloadedNodes = {};
+ if (isXML && !isArrayCells && cells != null) {
+ // reading of simple children nodes by name can be relatively slow
+ // because one enumerates all children nodes to find the node with
+ // specified name
+ children = cells.childNodes;
+ nChildren = children.length;
+ for (iChild = 0; iChild < nChildren; iChild++) {
+ child = children[iChild];
+ if (child.nodeType === 1) {
+ preloadedNodes[child.nodeName] = child;
+ }
+ }
+ // TODO: one can consider to examine cells.attributes and
+ // to save all values in preloadedAttributes map.
+ }
+ for (cmName in arrayReaderInfos) {
+ if (arrayReaderInfos.hasOwnProperty(cmName)) {
+ info = arrayReaderInfos[cmName];
+ if (isArrayCells) {
+ v = cells[info.order];
+ if (isXML && v != null) {
+ v = v.textContent || v.text;
+ }
+ } else if (colReader[cmName] != null && typeof colReader[cmName] !== "string") { // isFunction(colReader[cmName])
+ v = colReader[cmName].call(self, cells, { cmName: cmName, iItem: i });
+ } else {
+ v = fieldReader(cells, typeof colReader[cmName] === "string" ? colReader[cmName] : info.name);
+ }
+ if (info.type === 1) { // additional property
+ addProp = additionalProperties[info.index];
+ if (addProp != null && isFunction(addProp.convert)) {
+ v = addProp.convert(v, cells);
+ }
+ }
+ if (v !== undefined) {
+ rd[cmName] = v;
+ }
+ }
+ }
+
+ // read id.
+ if (rd[idName] !== undefined) {
+ // the id should be already read in p.keyName column.
+ // One need generate id only if the input data had no id
+ id = rd[idName] !== undefined ? rd[idName] : randId(); //id = br + i;
+ } else {
+ id = fieldReader(cur, isArray(cur) ? idIndex : idName);
+ if (id === undefined) {
+ id = fieldReader(cells, isArray(cells) ? idIndex : idName);
+ }
+ if (id === undefined) {
+ id = randId(); //id = br + i;
+ }
+ }
+ if (rd[idName] === undefined) {
+ rd[idName] = id;
+ }
+ id = String(id);
+ idr = p.idPrefix + id;
+
+ if (p.treeGrid) { normalizeTreeGridProperties(rd); }
+
+ // final steps of reading the row
+ if (i < rn) {
+ ids.push(idr);
+ cellsToDisplay.push(cells);
+ items.push(rd);
+ } else if (!readAllInputData) {
+ break;
+ }
+ if (readAllInputData || p.treeGrid === true) {
+ rd[locid] = id; //stripGridPrefix(idr);
+ p.data.push(rd);
+ addItemDataToColumnIndex(rd, id);
+ p._index[rd[locid]] = p.data.length - 1;
+ }
+ }
+ if (readAllInputData && p.treeGrid !== true) {
+ if (p.forceClientSorting) {
+ // don't display the data, just read it.
+ return;
+ }
+ // initialize lastSelectedData to simplify the usage of lastSelectedData
+ p.lastSelectedData = p.data.slice();
+ }
+
+ // of rd items plus array cells items (almost the same as drows).
+ // The second loop (from 0 till min(len,rn)) will build rowData from the both arrays
+ // Then one place rowData AT ONCE to the body any calls afterInsertRow in the loop
+ // for every inserted row.
+ // Finally one clean up the both arrays
+ var rowData = jgrid.parseDataToHtml.call(self, len, ids, items, cellsToDisplay, rcnt, adjust, readAllInputData);
+ fillOrClearCellBuilder(true); // clear cellBuilders
+
+ // place the HTML string fragments collected in rowData in the body of grid
+ var fpos = p.treeANode > -1 ? p.treeANode : 0;
+ var $tbody = $(self.tBodies[0]);
+ if (p.treeGrid === true && fpos > 0) {
+ $(self.rows[fpos]).after(rowData.join(""));
+ } else if (p.scroll) {
+ $tbody.append(rowData.join(""));
+ } else if (self.firstElementChild == null || (document.documentMode !== undefined && document.documentMode <= 9)) {
+ // for IE8 for example
+ $tbody.html($tbody.html() + rowData.join("")); // append to innerHTML of tbody which contains the first row (.jqgfirstrow)
+ self.grid.cols = self.rows[0].cells; // update cached first row
+ } else {
+ self.firstElementChild.innerHTML += rowData.join(""); // append to innerHTML of tbody which contains the first row (.jqgfirstrow)
+ self.grid.cols = self.rows[0].cells; // update cached first row
+ }
+
+ // refresh rowIndexes cash in case of usage grouping
+ if (p.grouping) {
+ rebuildRowIndexes.call(self);
+ }
+
+ //
+ if (p.subGrid === true) {
+ // make subgrid specific actions: bind click event handler to "+"
+ try { $j.addSubGrid.call($self, p.iColByName.subgrid); } catch (ignore) { }
+ }
+ if (p.gridview === false || isFunction(p.afterInsertRow)) {
+ for (i = 0; i < Math.min(len, rn); i++) {
+ feedback.call(self, "afterInsertRow", ids[i], items[i], cellsToDisplay[i]);
+ }
+ }
+ p.totaltime = new Date() - startReq;
+ if (i > 0) {
+ if (p.records === 0) { p.records = len; }
+ }
+ clearArray(rowData);
+ if (p.treeGrid === true) {
+ try { $j.setTreeNode.call($self, fpos + 1, i + fpos + 1); } catch (ignore) { }
+ }
+ p.reccount = Math.min(len, rn);
+ p.treeANode = -1;
+ if (p.userDataOnFooter) { $j.footerData.call($self, "set", p.userData, true); }
+ if (readAllInputData) {
+ p.records = len;
+ p.lastpage = Math.ceil(len / rn);
+ }
+ if (!more) { self.updatepager(false, true); }
+ finalizationFormatters.call(self);
+ },
+ addLocalData = function () {
+ var $self = $(this), st = p.multiSort ? [] : "", sto = {}, fndsort = false, cmtypes = {}, grtypes = [], grindexes = [],
+ defSrcFormat = getRes("formatter.date.srcformat"),
+ defNewFormat = getRes("formatter.date.newformat");
+ if (!isArray(p.data)) {
+ return {};
+ }
+ if (p.multiSort) {
+ getSortNames(st, sto);
+ }
+ var grpview = p.grouping ? p.groupingView : false, lengrp, gin,
+ processColModel = function (cm, iCol1, isAddProp) {
+ var srcformat, newformat,
+ grindex = cm.index || cm.name,
+ sorttype = cm.sorttype || "text";
+ cmtypes[cm.name] = {
+ reader: !p.dataTypeOrg ? cm.jsonmap || cm.name : cm.name,
+ iCol: iCol1,
+ stype: sorttype,
+ srcfmt: "",
+ newfmt: "",
+ sfunc: cm.sortfunc || null,
+ isAddProp: isAddProp === true ? true : false
+ };
+ if (sorttype === "date" || sorttype === "datetime") {
+ if (cm.formatter && typeof cm.formatter === "string" && cm.formatter === "date") {
+ if (cm.formatoptions && cm.formatoptions.srcformat) {
+ srcformat = cm.formatoptions.srcformat;
+ } else {
+ srcformat = defSrcFormat;
+ }
+ if (cm.formatoptions && cm.formatoptions.newformat) {
+ newformat = cm.formatoptions.newformat;
+ } else {
+ newformat = defNewFormat;
+ }
+ } else {
+ srcformat = newformat = cm.datefmt || "Y-m-d";
+ }
+ cmtypes[cm.name].srcfmt = srcformat;
+ cmtypes[cm.name].newfmt = newformat;
+ }
+ if (p.grouping) {
+ for (gin = 0, lengrp = grpview.groupField.length; gin < lengrp; gin++) {
+ if (cm.name === grpview.groupField[gin]) {
+ grtypes[gin] = cmtypes[grindex];
+ grindexes[gin] = grindex;
+ }
+ }
+ }
+ if (!p.multiSort) {
+ if (!fndsort && (cm.index === p.sortname || cm.name === p.sortname)) {
+ st = cm.name; // ???
+ fndsort = true;
+ }
+ }
+ };
+ each(p.colModel, function (iCol1) {
+ processColModel(this, iCol1);
+ });
+ each(p.additionalProperties, function (iCol1) {
+ processColModel(
+ typeof this === "string" ? { name: this } : this,
+ iCol1,
+ true
+ );
+ });
+ if (p.treeGrid) {
+ $j.SortTree.call($self, st, p.sortorder,
+ cmtypes[st] != null && cmtypes[st].stype ? cmtypes[st].stype : "text",
+ cmtypes[st] != null && cmtypes[st].srcfmt ? cmtypes[st].srcfmt : "");
+ return false;
+ }
+ var compareFnMap = {
+ "eq": function (queryObj) { return queryObj.equals; },
+ "ne": function (queryObj) { return queryObj.notEquals; },
+ "lt": function (queryObj) { return queryObj.less; },
+ "le": function (queryObj) { return queryObj.lessOrEquals; },
+ "gt": function (queryObj) { return queryObj.greater; },
+ "ge": function (queryObj) { return queryObj.greaterOrEquals; },
+ "cn": function (queryObj) { return queryObj.contains; },
+ "nc": function (queryObj, op) { return op === "OR" ? queryObj.orNot().contains : queryObj.andNot().contains; },
+ "bw": function (queryObj) { return queryObj.startsWith; },
+ "bn": function (queryObj, op) { return op === "OR" ? queryObj.orNot().startsWith : queryObj.andNot().startsWith; },
+ "en": function (queryObj, op) { return op === "OR" ? queryObj.orNot().endsWith : queryObj.andNot().endsWith; },
+ "ew": function (queryObj) { return queryObj.endsWith; },
+ "ni": function (queryObj, op) { return op === "OR" ? queryObj.orNot().inSet : queryObj.andNot().inSet; },
+ "in": function (queryObj) { return queryObj.inSet; },
+ "nu": function (queryObj) { return queryObj.isNull; },
+ "nn": function (queryObj, op) { return op === "OR" ? queryObj.orNot().isNull : queryObj.andNot().isNull; }
+ },
+ query = jgrid.from.call(this, p.data);
+ if (p.ignoreCase) { query = query.ignoreCase(); }
+ function tojLinq(group) {
+ var s = 0, index, gor, ror, opr, rule, r, cmi1;
+ if (group.groups != null) {
+ gor = group.groups.length && group.groupOp.toString().toUpperCase() === "OR";
+ if (gor) {
+ query.orBegin();
+ }
+ for (index = 0; index < group.groups.length; index++) {
+ if (s > 0 && gor) {
+ query.or();
+ }
+ try {
+ tojLinq(group.groups[index]);
+ } catch (e) { fatalErrorFunction(e); }
+ s++;
+ }
+ if (gor) {
+ query.orEnd();
+ }
+ }
+ if (group.rules != null) {
+ try {
+ ror = group.rules.length && group.groupOp.toString().toUpperCase() === "OR";
+ if (ror) {
+ query.orBegin();
+ }
+ for (index = 0; index < group.rules.length; index++) {
+ rule = group.rules[index];
+ opr = group.groupOp.toString().toUpperCase();
+ if (compareFnMap[rule.op] && rule.field) {
+ if (s > 0 && opr && opr === "OR") {
+ query = query.or();
+ }
+ cmi1 = cmtypes[rule.field];
+ if (cmi1 != null) {
+ r = cmi1.reader;
+ query = compareFnMap[rule.op](query, opr)(
+ isFunction(r) ?
+ "jQuery.jgrid.getAccessor(this,jQuery(\"" + p.idSel + "\")[0].p.colModel[" + cmi1.iCol + "].jsonmap)" :
+ "jQuery.jgrid.getAccessor(this,'" + r + "')",
+ rule.data,
+ cmtypes[rule.field]
+ );
+ }
+ } else if (p.customSortOperations != null && p.customSortOperations[rule.op] != null && isFunction(p.customSortOperations[rule.op].filter)) {
+ query = query.custom(rule.op, rule.field, rule.data);
+ }
+ s++;
+ }
+ if (ror) {
+ query.orEnd();
+ }
+ } catch (g) { fatalErrorFunction(g); }
+ }
+ }
+ if (p.search === true) {
+ var srules = p.postData[(p.searching || {}).sFilter || p.prmNames.filters];
+ if (srules) {
+ if (typeof srules === "string") { srules = $.parseJSON(srules); }
+ tojLinq(srules);
+ } else {
+ try {
+ var cmtypes1 = cmtypes[p.postData.searchField];
+ query = compareFnMap[p.postData.searchOper](query)(
+ //p.postData.searchField,
+ isFunction(cmtypes1.reader) ?
+ "jQuery.jgrid.getAccessor(this,jQuery(\"" + p.idSel + "\")[0].p.colModel[" + cmtypes1.iCol + "].jsonmap)" :
+ "jQuery.jgrid.getAccessor(this,'" + cmtypes1.reader + "')",
+ p.postData.searchString,
+ cmtypes[p.postData.searchField]
+ );
+ } catch (ignore) { }
+ }
+ }
+ if (p.grouping) {
+ for (gin = 0; gin < lengrp && gin < grindexes.length && gin < grtypes.length; gin++) {
+ query.orderBy(grindexes[gin], grpview.groupOrder[gin], grtypes[gin].stype, grtypes[gin].srcfmt);
+ }
+ }
+ if (p.multiSort) {
+ each(st, function () {
+ query.orderBy(this, sto[this], cmtypes[this].stype, cmtypes[this].srcfmt, cmtypes[this].sfunc);
+ });
+ } else if (st && p.sortorder && fndsort) {
+ query.orderBy(p.sortname, p.sortorder.toUpperCase() === "DESC" ? "d" : "a", cmtypes[st].stype, cmtypes[st].srcfmt, cmtypes[st].sfunc);
+ }
+ p.lastSelectedData = query.select();
+ var recordsperpage = parseInt(p.rowNum, 10),
+ total = p.lastSelectedData.length,
+ page = parseInt(p.page, 10),
+ totalpages = Math.ceil(total / recordsperpage),
+ retresult = {};
+ if (p.grouping && p.groupingView._locgr) {
+ p.groupingView.groups = [];
+ var j, key, udc;
+ if (p.footerrow && p.userDataOnFooter) {
+ for (key in p.userData) {
+ if (p.userData.hasOwnProperty(key)) {
+ p.userData[key] = 0;
+ }
+ }
+ udc = true;
+ }
+ for (j = 0; j < total; j++) {
+ if (udc) {
+ for (key in p.userData) {
+ if (p.userData.hasOwnProperty(key)) {
+ p.userData[key] += parseFloat(p.lastSelectedData[j][key] || 0);
+ }
+ }
+ }
+ $j.groupingPrepare.call($self, p.lastSelectedData[j], j, recordsperpage);
+ }
+ }
+ query = null;
+ cmtypes = null;
+ var localReader = p.localReader;
+ retresult[localReader.total] = totalpages;
+ retresult[localReader.page] = page;
+ retresult[localReader.records] = total;
+ retresult[localReader.root] = p.lastSelectedData.slice((page - 1) * recordsperpage, page * recordsperpage);
+ retresult[localReader.userdata] = p.userData;
+ return retresult;
+ },
+ setWidthOfPagerTdWithPager = function ($pgTable) {
+ var self = this, width = $pgTable.outerWidth(), fontSize;
+ if (width <= 0) { // not visible
+ fontSize = $(self).closest(".ui-jqgrid>.ui-jqgrid-view").css("font-size") || "11px";
+ $(document.body).append("
");
+ $($pgTable).clone().appendTo("#testpg");
+ width = $("#testpg>.ui-pg-table").width();
+ $("#testpg").remove();
+ }
+ if (width > 0) {
+ $pgTable.parent().width(width);
+ }
+ return width;
+ },
+ updatepager = function (rn, dnd) {
+ var self = this, $self = $(self), gridSelf = self.grid, cp, last, base1, from, to, tot, fmt, pgboxes = p.pager || "", sppg,
+ tspg = p.pager ? "_" + p.pager.substr(1) : "", bDiv = gridSelf.bDiv, numberFormat = $.fmatter ? $.fmatter.NumberFormat : null,
+ tspgTop = p.toppager ? "_" + p.toppager.substr(1) : "",
+ hoverClasses = getGuiStyles("states.hover"), disabledClasses = getGuiStyles("states.disabled");
+ base1 = parseInt(p.page, 10) - 1;
+ if (base1 < 0) { base1 = 0; }
+ base1 = base1 * parseInt(p.rowNum, 10);
+ to = base1 + p.reccount;
+ if (p.scroll) {
+ var rows = $(getGridComponent(COMPONENT_NAMES.BODY_TABLE, bDiv)[0].rows).slice(1);//$("tbody:first > tr:gt(0)", bDiv);
+ base1 = to - rows.length;
+ p.reccount = rows.length;
+ var rh = rows.outerHeight() || gridSelf.prevRowHeight;
+ if (rh) {
+ var top = base1 * rh;
+ var height = jgrid.fixMaxHeightOfDiv.call(self, parseInt(p.records, 10) * rh);
+ $(bDiv).children("div").first().css({ height: height + "px" })
+ .children("div").first().css({ height: top + "px", display: top + "px" ? "" : "none" });
+ if (bDiv.scrollTop === 0 && p.page > 1) {
+ bDiv.scrollTop = p.rowNum * (p.page - 1) * rh;
+ }
+ }
+ bDiv.scrollLeft = gridSelf.hDiv.scrollLeft;
+ }
+ pgboxes += p.toppager ? (pgboxes ? "," : "") + p.toppager : "";
+ if (pgboxes) {
+ fmt = getRes("formatter.integer") || {};
+ cp = intNum(p.page);
+ last = intNum(p.lastpage);
+ $(".selbox", pgboxes).prop("disabled", false);
+ if (p.pginput === true) {
+ var $pagerInputs = $(".ui-pg-input", pgboxes),
+ numberOfDigitsInPageNumber = String(p.page).length;
+ $pagerInputs.val(p.page);
+ // verify the value of size attribute of "input.ui-pg-input"
+ // and increase it if it's required.
+ $pagerInputs.each(function () {
+ var size = parseInt($(this).attr("size"), 10);
+ if (size > 0 && size < numberOfDigitsInPageNumber) {
+ $(this).attr("size", numberOfDigitsInPageNumber);
+ }
+ });
+ sppg = p.toppager ? "#sp_1" + tspg + ",#sp_1" + tspgTop : "#sp_1" + tspg;
+ $(sppg).html($.fmatter ? numberFormat(p.lastpage, fmt) : p.lastpage)
+ .closest(".ui-pg-table").each(function () {
+ setWidthOfPagerTdWithPager.call(self, $(this));
+ });
+ }
+ if (p.viewrecords) {
+ if (p.reccount === 0) {
+ $(".ui-paging-info", pgboxes).html(getDef("emptyrecords"));
+ } else {
+ from = base1 + 1;
+ tot = p.records;
+ if ($.fmatter) {
+ from = numberFormat(from, fmt);
+ to = numberFormat(to, fmt);
+ tot = numberFormat(tot, fmt);
+ }
+ $(".ui-paging-info", pgboxes).html(jgrid.format(getDef("recordtext"), from, to, tot));
+ }
+ }
+ if (p.pgbuttons === true) {
+ if (last <= 0) { cp = 0;}
+ if (cp <= 0) { cp = last = 0; }
+ if (cp === 1 || cp === 0) {
+ $("#first" + tspg + ", #prev" + tspg).addClass(disabledClasses).removeClass(hoverClasses);
+ if (p.toppager) { $("#first_t" + tspgTop + ", #prev_t" + tspgTop).addClass(disabledClasses).removeClass(hoverClasses); }
+ } else {
+ $("#first" + tspg + ", #prev" + tspg).removeClass(disabledClasses);
+ if (p.toppager) { $("#first_t" + tspgTop + ", #prev_t" + tspgTop).removeClass(disabledClasses); }
+ }
+ if (cp === last || cp === 0) {
+ $("#next" + tspg + ", #last" + tspg).addClass(disabledClasses).removeClass(hoverClasses);
+ if (p.toppager) { $("#next_t" + tspgTop + ", #last_t" + tspgTop).addClass(disabledClasses).removeClass(hoverClasses); }
+ } else {
+ $("#next" + tspg + ", #last" + tspg).removeClass(disabledClasses);
+ if (p.toppager) { $("#next_t" + tspgTop + ", #last_t" + tspgTop).removeClass(disabledClasses); }
+ }
+ }
+ }
+ if (rn === true && p.rownumbers === true) {
+ $(">td.jqgrid-rownum", self.rows).each(function (i) {
+ $(this).html(base1 + 1 + i);
+ });
+ }
+ if (dnd && p.jqgdnd) { $self.jqGrid("gridDnD", "updateDnD"); }
+ feedback.call(self, "gridComplete");
+ $self.triggerHandler("jqGridAfterGridComplete");
+ },
+ beginReq = function () {
+ var self = this;
+ self.grid.hDiv.loading = true;
+ if (p.hiddengrid) { return; }
+ $j.progressBar.call($(self), { method: "show", loadtype: p.loadui, htmlcontent: getDef("loadtext") });
+ },
+ endReq = function () {
+ var self = this;
+ self.grid.hDiv.loading = false;
+ $j.progressBar.call($(self), { method: "hide", loadtype: p.loadui });
+ },
+ populate = function (npage) {
+ var self = this, $self = $(self), gridSelf = self.grid;
+ if (!gridSelf.hDiv.loading) {
+ var pvis = p.scroll && npage === false, prm = {}, dt, dstr, pN = p.prmNames;
+ if (p.page <= 0) { p.page = Math.min(1, p.lastpage); }
+ if (pN.search !== null) { prm[pN.search] = p.search; }
+ if (pN.nd !== null) { prm[pN.nd] = new Date().getTime(); }
+ if (isNaN(parseInt(p.rowNum, 10)) || parseInt(p.rowNum, 10) <= 0) { p.rowNum = p.maxRowNum; }
+ if (pN.rows !== null) { prm[pN.rows] = p.rowNum; }
+ if (pN.page !== null) { prm[pN.page] = p.page; }
+ if (pN.sort !== null) { prm[pN.sort] = p.sortname; }
+ if (pN.order !== null) { prm[pN.order] = p.sortorder; }
+ if (p.rowTotal !== null && pN.totalrows !== null) { prm[pN.totalrows] = p.rowTotal; }
+ var lcf = isFunction(p.loadComplete), lc = lcf ? p.loadComplete : null;
+ var adjust = 0;
+ npage = npage || 1;
+ if (npage > 1) {
+ if (pN.npage !== null) {
+ prm[pN.npage] = npage;
+ adjust = npage - 1;
+ npage = 1;
+ } else {
+ lc = function (data) {
+ p.page++;
+ gridSelf.hDiv.loading = false;
+ if (lcf) {
+ p.loadComplete.call(self, data);
+ }
+ populate.call(self, npage - 1);
+ };
+ }
+ } else if (pN.npage !== null) {
+ delete p.postData[pN.npage];
+ }
+ if (p.grouping && $j.groupingSetup) {
+ $j.groupingSetup.call($self);
+ var grp = p.groupingView, gi, gs = "", index, iColumn, cmValue;
+ for (gi = 0; gi < grp.groupField.length; gi++) {
+ index = grp.groupField[gi];
+ for (iColumn = 0; iColumn < p.colModel.length; iColumn++) {
+ cmValue = p.colModel[iColumn];
+ if (cmValue.name === index && cmValue.index) {
+ index = cmValue.index;
+ }
+ }
+ gs += index + " " + grp.groupOrder[gi] + ", ";
+ }
+ prm[pN.sort] = gs + prm[pN.sort];
+ }
+ extend(p.postData, prm);
+ var rcnt = !p.scroll ? 1 : self.rows.length - 1,
+ fixDisplayingHorizontalScrollbar = function () {
+ fixScrollOffsetAndhBoxPadding.call(self);
+ // if no items are displayed in the btable, but the column header is too wide
+ // the horizontal scrollbar of bDiv will be disabled.
+ if (!p.autowidth && (p.widthOrg === undefined || p.widthOrg === "auto" || p.widthOrg === "100%")) {
+ $j.setGridWidth.call($self, p.tblwidth + p.scrollOffset, false);
+ }
+ },
+ resort = function () {
+ var iRes;
+ if (p.autoresizeOnLoad) {
+ $j.autoResizeAllColumns.call($self);
+ clearArray(p.columnsToReResizing);
+ if (p.autowidth) {
+ $j.setGridWidth.call($self,
+ $self.closest(".ui-jqgrid").parent().width(),
+ true);
+ }
+ } else {
+ for (iRes = 0; iRes < p.columnsToReResizing.length; iRes++) {
+ $j.autoResizeColumn.call($self, p.columnsToReResizing[iRes]);
+ }
+ clearArray(p.columnsToReResizing);
+ }
+ },
+ finalReportSteps = function () {
+ feedback.call(self, "loadComplete", dstr);
+ resort();
+ $self.triggerHandler("jqGridAfterLoadComplete", [dstr]);
+ endReq.call(self);
+ p.datatype = "local";
+ p.datastr = null;
+ fixDisplayingHorizontalScrollbar();
+ },
+ finalReportVirtual = function (data) {
+ $self.triggerHandler("jqGridLoadComplete", [data]);
+ if (lc) { lc.call(self, data); }
+ resort();
+ $self.triggerHandler("jqGridAfterLoadComplete", [data]);
+ if (pvis) { gridSelf.populateVisible.call(self); }
+ if (npage === 1) { endReq.call(self); }
+ fixDisplayingHorizontalScrollbar();
+ },
+ readLocal = function () {
+ var req = addLocalData.call(self);
+ readInput.call(self, req, rcnt, npage > 1, adjust);
+ finalReportVirtual(req);
+ };
+ if (!feedback.call(self, "beforeRequest")) { return; }
+ if (isFunction(p.datatype)) { p.datatype.call(self, p.postData, "load_" + p.id, rcnt, npage, adjust); return; }
+ dt = p.datatype.toLowerCase();
+ $(grid.eDiv).hide();
+ switch (dt) {
+ case "json":
+ case "jsonp":
+ case "xml":
+ case "script":
+ $.ajax(extend({
+ url: p.url,
+ type: p.mtype,
+ dataType: dt,
+ //data: $.isFunction(p.serializeGridData)? p.serializeGridData.call(self,p.postData) : p.postData,
+ data: jgrid.serializeFeedback.call(ts, p.serializeGridData, "jqGridSerializeGridData", p.postData),
+ success: function (data, textStatus, jqXHR) {
+ p.jqXhr = null;
+ $(grid.eDiv).hide();
+ if (isFunction(p.beforeProcessing)) {
+ if (p.beforeProcessing.call(self, data, textStatus, jqXHR) === false) {
+ endReq.call(self);
+ return;
+ }
+ }
+ readInput.call(self, data, rcnt, npage > 1, adjust);
+ finalReportVirtual(data);
+ if (p.loadonce || p.treeGrid) {
+ p.dataTypeOrg = p.datatype;
+ p.datatype = "local";
+ if (p.forceClientSorting) { readLocal(); }
+ }
+ },
+ error: function (jqXHR, textStatus, errorThrown) {
+ p.jqXhr = null;
+ if (isFunction(p.loadError)) { p.loadError.call(self, jqXHR, textStatus, errorThrown); }
+ if (npage === 1) { endReq.call(self); }
+ },
+ beforeSend: function (jqXHR, settings) {
+ var gotoreq = true;
+ if (isFunction(p.loadBeforeSend)) {
+ gotoreq = p.loadBeforeSend.call(self, jqXHR, settings);
+ }
+ if (gotoreq === undefined) { gotoreq = true; }
+ if (gotoreq === false) {
+ return false;
+ }
+ p.jqXhr = jqXHR;
+ beginReq.call(self);
+ }
+ }, jgrid.ajaxOptions, p.ajaxGridOptions));
+ break;
+ case "xmlstring":
+ beginReq.call(self);
+ dstr = typeof p.datastr === "string" ? $.parseXML(p.datastr) : p.datastr;
+ readInput.call(self, dstr);
+ finalReportSteps();
+ if (p.forceClientSorting) { readLocal(); }
+ break;
+ case "jsonstring":
+ beginReq.call(self);
+ dstr = p.datastr && typeof p.datastr === "string" ? $.parseJSON(p.datastr) : p.datastr;
+ readInput.call(self, dstr);
+ finalReportSteps();
+ if (p.forceClientSorting) { readLocal(); }
+ break;
+ case "local":
+ case "clientside":
+ beginReq.call(self);
+ p.datatype = "local";
+ readLocal();
+ break;
+ }
+ }
+ },
+ setHeadCheckBox = function (checked) {
+ var self = this, gridSelf = self.grid;
+ $(p.cb, gridSelf.hDiv).prop("checked", checked);
+ if (p.frozenColumns) {
+ $(p.cb, gridSelf.fhDiv).prop("checked", checked);
+ }
+ },
+ setPager = function (pgid, tp) {
+ var hoverClasses = getGuiStyles("states.hover"), disabledClasses = getGuiStyles("states.disabled"),
+ sep = "",
+ str = "", pgcnt, lft, cent, rgt, twd, i,
+ clearVals = function (onpaging, newPage, newRowNum) {
+ if (!feedback.call(ts, "onPaging", onpaging, {
+ newPage: newPage,
+ currentPage: intNum(p.page, 1),
+ lastPage: intNum(p.lastpage, 1),
+ currentRowNum: intNum(p.rowNum, 10),
+ newRowNum: newRowNum
+ })) {
+ return false;
+ }
+ p.selrow = null;
+ if (p.multiselect) {
+ if (!p.multiPageSelection) {
+ clearArray(p.selarrrow); // p.selarrrow = [];
+ }
+ setHeadCheckBox.call(ts, false);
+ }
+ clearArray(p.savedRow); // p.savedRow = [];
+ p.editingInfo = {};
+ return true;
+ };
+ tp += "_" + pgid;
+ pgcnt = "pg_" + pgid;
+ lft = pgid + "_left";
+ cent = pgid + "_center";
+ rgt = pgid + "_right";
+ $("#" + jqID(pgid))
+ .append("")
+ .attr("dir", "ltr"); //explicit setting
+ pgcnt = "#" + jqID(pgcnt); // modify to id selector
+ if (p.rowList.length > 0) {
+ str = "";
+ var pgrecs = getDef("pgrecs");
+ str += " ";
+ }
+ if (dir === "rtl") { pgl += str; }
+ if (p.pginput === true) { pginp = "" + jgrid.format(getDef("pgtext") || "", "", "0 ") + " "; }
+ pgid = "#" + jqID(pgid); // modify to id selector
+ if (p.pgbuttons === true) {
+ var po = ["first", "prev", "next", "last"],
+ poIcons = po.slice(),
+ buttonClasses = getGuiStyles("pager.pagerButton", "ui-pg-button"),
+ buildPagerButton = function (buttonName, iconName) {
+ var titleText = getDef("pg" + buttonName);
+ return "
";
+ if (p.viewrecords === true) { $("td" + pgid + "_" + p.recordpos, pgcnt).append("", headerText,
+ tbody = " ",
+ hoverStateClasses = getGuiStyles("states.hover"),
+ disabledStateClasses = getGuiStyles("states.disabled");
+
+ if (p.multiSort) {
+ sortarr = p.sortname.split(",");
+ var iSort;
+ for (iSort = 0; iSort < sortarr.length; iSort++) {
+ sotmp = trim(sortarr[iSort]).split(" ");
+ sortarr[iSort] = trim(sotmp[0]);
+ sortord[iSort] = sotmp[1] ? trim(sotmp[1]) : p.sortorder || "asc";
+ }
+ }
+ for (iCol = 0; iCol < p.colNames.length; iCol++) {
+ cmi = p.colModel[iCol];
+ tooltip = p.headertitles || cmi.headerTitle ? (" title='" + stripHtml(typeof cmi.headerTitle === "string" ? cmi.headerTitle : p.colNames[iCol]) + "'") : "";
+ thead += "";
+ idn = cmi.index || cmi.name;
+ switch (cmi.labelAlign) {
+ case "left":
+ labelStyle = "text-align:left;";
+ break;
+ case "right":
+ labelStyle = "text-align:right;";
+ break;
+ case "likeData":
+ labelStyle = cmi.align === undefined || cmi.align === "left" ?
+ "text-align:left;" : (cmi.align === "right" ? "text-align:right;" : "");
+ break;
+ default:
+ labelStyle = "";
+ }
+
+ thead += "";
+ headerText = (cmi.autoResizable && cmi.formatter !== "actions") || cmi.rotated ?
+ "" + p.colNames[iCol] + " " :
+ p.colNames[iCol];
+ if (p.sortIconsBeforeText) {
+ thead += (p.builderSortIcons || jgrid.builderSortIcons).call(ts, iCol);
+ thead += headerText;
+ } else {
+ thead += headerText;
+ thead += (p.builderSortIcons || jgrid.builderSortIcons).call(ts, iCol);
+ }
+ thead += "
";
+ tbody += " ";
+ tbody += "
");
+ $(p.rs)
+ .on("selectstart", function () {
+ return false;
+ })
+ .click(myResizerClickHandler)
+ .dblclick(function (e) {
+ var iColIndex = $(this).data("idx"),
+ pageX = $(this).data("pageX"),
+ cm = p.colModel[iColIndex];
+
+ if (pageX == null || cm == null) {
+ return false;
+ }
+ var arPageX = String(pageX).split(";"),
+ pageX1 = parseFloat(arPageX[0]),
+ pageX2 = parseFloat(arPageX[1]);
+ if (arPageX.length === 2 && (Math.abs(pageX1 - pageX2) > 5 || Math.abs(e.pageX - pageX1) > 5 || Math.abs(e.pageX - pageX2) > 5)) {
+ return false;
+ }
+ if (feedback.call(ts, "resizeDblClick", iColIndex, cm, e) && cm.autoResizable) {
+ $j.autoResizeColumn.call($self0, iColIndex);
+ }
+ feedback.call(ts, "afterResizeDblClick", { iCol: iColIndex, cm: cm, cmName: cm.name });
+
+ return false; // stop propagate
+ });
+ $(gv).css("width", grid.width + "px");
+ var tfoot = "";
+ if (p.footerrow) {
+ tfoot += ""; }
+ firstr += "";
+ $self0.html("" + firstr + " ");
+ //firstr = null;
+ $self0.addClass(getGuiStyles("grid", "ui-jqgrid-btable" + (p.altRows === true && $self0.jqGrid("isBootstrapGuiStyle") ? " table-striped" : "")));
+ var hg = (p.caption && p.hiddengrid === true) ? true : false,
+ hb = $("
"),
+ topClasses = getGuiStyles("top"),
+ bottomClasses = getGuiStyles("bottom");
+ grid.hDiv = document.createElement("div");
+ $(grid.hDiv)
+ .css({ width: grid.width + "px" })
+ .addClass(getGuiStyles("hDiv", "ui-jqgrid-hdiv"))
+ .append(hb)
+ .scroll(function () {
+ // the hDiv can be scrolled because of tab keyboard navigation
+ // we have to sync bDiv and hDiv scrollLeft in the case
+ var bDiv = $(this).next(".ui-jqgrid-bdiv")[0];
+ if (bDiv) {
+ bDiv.scrollLeft = this.scrollLeft;
+ }
+ return false;
+ });
+ $(hb).append(hTable);
+ hTable = null;
+ if (hg) { $(grid.hDiv).hide(); }
+ p.rowNum = parseInt(p.rowNum, 10);
+ if (isNaN(p.rowNum) || p.rowNum <= 0) {
+ p.rowNum = p.maxRowNum;
+ }
+ if (p.pager) {
+ // see http://learn.jquery.com/using-jquery-core/faq/how-do-i-select-an-element-by-an-id-that-has-characters-used-in-css-notation/
+ // or http://api.jquery.com/id-selector/ or http://api.jquery.com/category/selectors/
+ // about the requirement to escape characters like ".", ":" or some other in case.
+ var $pager, pagerId;
+ if (typeof p.pager === "string" && p.pager.substr(0, 1) !== "#") {
+ pagerId = p.pager; // UNESCAPED id of the pager
+ $pager = $("#" + jqID(p.pager));
+ } else if (p.pager === true) {
+ pagerId = randId();
+ $pager = $("");
+ $pager.appendTo("body");
+ p.pager = "#" + jqID(pagerId);
+ } else {
+ $pager = $(p.pager); // jQuery wrapper or ESCAPED id selector
+ pagerId = $pager.attr("id");
+ }
+ if ($pager.length > 0) {
+ $pager.css({ width: grid.width + "px" }).addClass(getGuiStyles("pager.pager", "ui-jqgrid-pager " + bottomClasses)).appendTo(eg);
+ if (hg) { $pager.hide(); }
+ setPager.call(ts, pagerId, "");
+ p.pager = "#" + jqID(pagerId); // hold ESCAPED id selector in the pager
+ } else {
+ p.pager = ""; // clear wrong value of the pager option
+ }
+ }
+ if (p.cellEdit === false && p.hoverrows === true) {
+ $self0
+ .on("mouseover.jqGrid", function (e) {
+ ptr = $(e.target).closest("tr.jqgrow");
+ if ($(ptr).attr("class") !== "ui-subgrid") {
+ $(ptr).addClass(hoverStateClasses);
+ }
+ })
+ .on("mouseout.jqGrid", function (e) {
+ ptr = $(e.target).closest("tr.jqgrow");
+ $(ptr).removeClass(hoverStateClasses);
+ });
+ }
+ var getTdFromTarget = function (target) {
+ var $td, $tr, $table;
+ do {
+ $td = $(target).closest("td");
+ if ($td.length > 0) {
+ $tr = $td.parent();
+ $table = $tr.parent().parent();
+ if ($tr.is(".jqgrow") && ($table[0] === this || ($table.is("table.ui-jqgrid-btable") && ($table[0].id || "").replace("_frozen", "") === this.id))) {
+ break;
+ }
+ target = $td.parent();
+ }
+ } while ($td.length > 0);
+ return $td;
+ };
+ $self0.before(grid.hDiv)
+ .click(function (e) {
+ var highlightClass = getGuiStyles("states.select"), target = e.target,
+ $td = getTdFromTarget.call(ts, target), $tr = $td.parent();
+ // we uses ts.rows context below to be sure that we don't process the clicks in the subgrid
+ // probably one can change the rule and to step over the parents till one will have
+ // "tr.jqgrow>td" AND the parent of parent (the table element) will be ts.
+ // one can use the same processing in click, dblclick and contextmenu
+ //ptr = $(td, ts.rows).closest("tr.jqgrow");
+ if ($tr.length === 0 || hasOneFromClasses($tr, disabledStateClasses)) {
+ return;
+ }
+ var ri = $tr[0].id, ci = $td[0].cellIndex,
+ scb = $(target).hasClass("cbox") &&
+ $(target).is(":enabled") && !hasOneFromClasses(target, disabledStateClasses),
+ cSel = feedback.call(ts, "beforeSelectRow", ri, e), alreadySelected = false,
+ editingInfo = jgrid.detectRowEditing.call(ts, ri),
+ locked = editingInfo != null && editingInfo.mode !== "cellEditing"; // editingInfo.savedRow.ic
+ if (target.tagName === "A" || (locked && !scb)) { return; }
+ feedback.call(ts, "onCellSelect", ri, ci, $td.html(), e);
+ if (p.cellEdit === true) {
+ if (cSel && p.noCellSelection && (!p.multiselect || (scb && !p.multiboxonly))) {
+ setSelection.call($self0, ri, true, e);
+ alreadySelected = true;
+ }
+
+ try {
+ $j.editCell.call($self0, $tr[0].rowIndex, ci, true);
+ } catch (ignore) { }
+
+ if (!p.noCellSelection) {
+ return;
+ }
+ }
+ if (!cSel) {
+ if (scb) {
+ // selection is not allowed by beforeSelectRow, but the multiselect
+ // checkbox is clicked.
+ $(target).prop("checked", false);
+ }
+ return;
+ }
+ if (!p.multikey) {
+ if (p.multiselect && p.multiboxonly) {
+ if (scb && !alreadySelected) {
+ setSelection.call($self0, ri, true, e);
+ } else {
+ var frz = p.frozenColumns ? p.id + "_frozen" : "";
+ $(p.selarrrow).each(function (i, n) {
+ var trid = $j.getGridRowById.call($self0, n);
+ if (trid) { $(trid).removeClass(highlightClass); }
+ $("#jqg_" + jqID(p.id) + "_" + jqID(n)).prop("checked", false);
+ if (frz) {
+ $("#" + jqID(n), "#" + jqID(frz)).removeClass(highlightClass);
+ $("#jqg_" + jqID(p.id) + "_" + jqID(n), "#" + jqID(frz)).prop("checked", false);
+ }
+ });
+ clearArray(p.selarrrow); // p.selarrrow = [];
+ if (!alreadySelected) {
+ setSelection.call($self0, ri, true, e);
+ }
+ }
+ } else {
+ var oldSelRow = p.selrow;
+ if (!alreadySelected) {
+ setSelection.call($self0, ri, true, e);
+ }
+ if (p.singleSelectClickMode === "toggle" && !p.multiselect && oldSelRow === ri) {
+ if (ts.grid.fbRows) {
+ $tr = $tr.add(
+ ts.grid.fbRows[$tr[0].rowIndex] === $tr[0] ?
+ ts.rows[$tr[0].rowIndex] :
+ ts.grid.fbRows[$tr[0].rowIndex]
+ );
+ }
+ $tr.removeClass(highlightClass).attr({ "aria-selected": "false", "tabindex": "-1" });
+ p.selrow = null;
+ }
+ }
+ } else {
+ if (e[p.multikey] && !alreadySelected) {
+ setSelection.call($self0, ri, true, e);
+ } else if (p.multiselect && scb) {
+ scb = $("#jqg_" + jqID(p.id) + "_" + ri).is(":checked");
+ $("#jqg_" + jqID(p.id) + "_" + ri).prop("checked", !scb);
+ }
+ }
+ // it's important don't use return false in the event handler
+ // the usage of return false break checking/uchecking
+ })
+ .on("reloadGrid", function (e, opts) {
+ var self = this, gridSelf = self.grid, $self = $(this);
+ if (p.treeGrid === true) {
+ p.datatype = p.treedatatype;
+ }
+ opts = extend({}, defaults.reloadGridOptions || {}, p.reloadGridOptions || {}, opts || {});
+ if (p.datatype === "local" && p.dataTypeOrg && p.loadonce && opts.fromServer) {
+ p.datatype = p.dataTypeOrg;
+ delete p.dataTypeOrg;
+ }
+ if (opts.current) {
+ gridSelf.selectionPreserver.call(self);
+ }
+ if (p.datatype === "local") {
+ if (!p.multiPageSelection) {
+ $j.resetSelection.call($self);
+ }
+ if (p.data.length) {
+ normalizeData.call(self);
+ refreshIndex.call(self);
+ }
+ } else if (!p.treeGrid && !p.multiPageSelection) {
+ p.selrow = null;
+ if (p.multiselect) {
+ clearArray(p.selarrrow); // p.selarrrow = [];
+ setHeadCheckBox.call(self, false);
+ }
+ clearArray(p.savedRow); // p.savedRow = [];
+ p.editingInfo = {};
+ }
+ p.iRow = -1;
+ p.iCol = -1;
+ if (p.scroll) { grid.emptyRows.call(self, true, false); }
+ if (opts.page) {
+ var page = parseInt(opts.page, 10);
+ if (page > p.lastpage) { page = p.lastpage; }
+ if (page < 1) { page = 1; }
+ p.page = page;
+ if (gridSelf.prevRowHeight) {
+ gridSelf.bDiv.scrollTop = (page - 1) * gridSelf.prevRowHeight * p.rowNum;
+ } else {
+ gridSelf.bDiv.scrollTop = 0;
+ }
+ }
+ if (gridSelf.prevRowHeight && p.scroll && opts.page === undefined) {
+ delete p.lastpage;
+ gridSelf.populateVisible.call(self);
+ } else {
+ gridSelf.populate.call(self);
+ }
+ if (p._inlinenav === true) { $self.jqGrid("showAddEditButtons", false); }
+ return false;
+ })
+ .dblclick(function (e) {
+ var $td = getTdFromTarget.call(ts, e.target), $tr = $td.parent();
+ // TODO: replace ts below to method which use $(this) in case of click
+ // on the grid and the table of the main grid if one click inside the FROZEN column
+ if ($td.length > 0 && !feedback.call(ts, "ondblClickRow", $tr.attr("id"), $tr[0].rowIndex, $td[0].cellIndex, e)) {
+ return false; // e.preventDefault() and e.stopPropagation() together
+ }
+ })
+ .on("contextmenu", function (e) {
+ var $td = getTdFromTarget.call(ts, e.target), $tr = $td.parent(), rowid = $tr.attr("id");
+ if ($td.length === 0) { return; }
+ if (!p.multiselect && p.selrow !== rowid && p.selectOnContextMenu === true) {
+ // TODO: replace $self0 and ts below to method which use $(this) in case of click
+ // on the grid and the table of the main grid if one click inside the FROZEN column
+ setSelection.call($self0, rowid, true, e);
+ }
+ if (!feedback.call(ts, "onRightClickRow", rowid, $tr[0].rowIndex, $td[0].cellIndex, e)) {
+ return false; // e.preventDefault() and e.stopPropagation() together
+ }
+ });
+ grid.bDiv = document.createElement("div");
+ if (isMSIE) { if (String(p.height).toLowerCase() === "auto") { p.height = "100%"; } }
+ $(grid.bDiv)
+ .append($("
").append("
").append(ts))
+ .addClass("ui-jqgrid-bdiv")
+ .css({ height: p.height + (isNaN(p.height) ? "" : "px"), width: (grid.width) + "px" })
+ .scroll(grid.scrollGrid);
+ if (p.maxHeight) {
+ $(grid.bDiv).css("max-height", p.maxHeight + (isNaN(p.maxHeight) ? "" : "px"));
+ }
+ $self0.css({ width: "1px" });
+ if (!$.support.tbody) { //IE
+ if ($(">tbody", ts).length === 2) { $(">tbody:gt(0)", ts).remove(); }
+ }
+ if (p.multikey) {
+ $(grid.bDiv).on(jgrid.msie ? "selectstart" : "mousedown", function () { return false; });
+ }
+ if (hg) { $(grid.bDiv).hide(); }
+ grid.cDiv = document.createElement("div");
+ var visibleGridIcon = getIcon("gridMinimize.visible"), hiddenGridIcon = getIcon("gridMinimize.hidden"), showhide = getDef("showhide"),
+ arf = p.hidegrid === true ?
+ $("" + p.caption + " ")
+ .append(arf)
+ .addClass(getGuiStyles("gridTitle", "ui-jqgrid-titlebar ui-jqgrid-caption" + (dir === "rtl" ? "-rtl " : " ") + topClasses));
+ $(grid.cDiv).insertBefore(grid.hDiv);
+ if (p.toolbar[0]) {
+ grid.uDiv = document.createElement("div");
+ if (p.toolbar[1] === "top") {
+ $(grid.uDiv).insertBefore(grid.hDiv);
+ } else if (p.toolbar[1] === "bottom") {
+ $(grid.uDiv).insertAfter(grid.hDiv);
+ }
+ var toolbarUpperClasses = getGuiStyles("toolbarUpper", "ui-userdata");
+ if (p.toolbar[1] === "both") {
+ grid.ubDiv = document.createElement("div");
+ $(grid.uDiv).addClass(toolbarUpperClasses).attr("id", "t_" + p.id).insertBefore(grid.hDiv);
+ $(grid.ubDiv).addClass(getGuiStyles("toolbarBottom", "ui-userdata")).attr("id", "tb_" + p.id).insertAfter(grid.hDiv);
+ if (hg) { $(grid.ubDiv).hide(); }
+ } else {
+ $(grid.uDiv).width(grid.width).addClass(toolbarUpperClasses).attr("id", "t_" + p.id);
+ }
+ if (hg) { $(grid.uDiv).hide(); }
+ }
+ if (typeof p.datatype === "string") {
+ p.datatype = p.datatype.toLowerCase();
+ }
+ if (p.toppager) {
+ p.toppager = p.id + "_toppager";
+ grid.topDiv = $("")[0];
+ $(grid.topDiv)
+ .addClass(getGuiStyles("pager.pager", "ui-jqgrid-toppager" + (p.caption ? "" : " " + topClasses)))
+ .css({ width: grid.width + "px" })
+ .insertBefore(grid.hDiv);
+ setPager.call(ts, p.toppager, "_t");
+ p.toppager = "#" + jqID(p.toppager); // hold ESCAPED id selector in the toppager option
+ } else if (p.pager === "" && !p.scroll) {
+ p.rowNum = p.maxRowNum;
+ }
+ if (p.footerrow) {
+ grid.sDiv = $("
")[0];
+ hb = $("
");
+ $(grid.sDiv).append(hb).width(grid.width).insertAfter(grid.hDiv);
+ $(hb).append(tfoot);
+ grid.footers = $(".ui-jqgrid-ftable", grid.sDiv)[0].rows[0].cells;
+ if (p.rownumbers) { grid.footers[0].className = getGuiStyles("rowNum", "jqgrid-rownum"); }
+ if (hg) { $(grid.sDiv).hide(); }
+ }
+ hb = null;
+ if (p.caption) {
+ var tdt = p.datatype;
+ if (p.hidegrid === true) {
+ $(".ui-jqgrid-titlebar-close", grid.cDiv).click(function (e) {
+ var elems = ".ui-jqgrid-bdiv,.ui-jqgrid-hdiv,.ui-jqgrid-pager,.ui-jqgrid-sdiv", self = this;
+ if (p.toolbar[0] === true) {
+ if (p.toolbar[1] === "both") {
+ elems += ",#" + jqID($(grid.ubDiv).attr("id"));
+ }
+ elems += ",#" + jqID($(grid.uDiv).attr("id"));
+ }
+ var counter = $(elems, p.gView).length;
+ if (p.toppager) {
+ elems += "," + p.toppager;
+ }
+
+ if (p.gridstate === "visible") {
+ $(elems, p.gBox).slideUp("fast", function () {
+ counter--;
+ if (counter === 0) {
+ $("span", self).removeClass(visibleGridIcon).addClass(hiddenGridIcon);
+ p.gridstate = "hidden";
+ if ($(p.gBox).hasClass("ui-resizable")) { $(".ui-resizable-handle", p.gBox).hide(); }
+ $(grid.cDiv).addClass(bottomClasses);
+ if (!hg) { feedback.call(ts, "onHeaderClick", p.gridstate, e); }
+ }
+ });
+ } else if (p.gridstate === "hidden") {
+ $(grid.cDiv).removeClass(bottomClasses);
+ $(elems, p.gBox).slideDown("fast", function () {
+ counter--;
+ if (counter === 0) {
+ $("span", self).removeClass(hiddenGridIcon).addClass(visibleGridIcon);
+ if (hg) { p.datatype = tdt; populate.call(ts); hg = false; }
+ p.gridstate = "visible";
+ if ($(p.gBox).hasClass("ui-resizable")) { $(".ui-resizable-handle", p.gBox).show(); }
+ if (!hg) { feedback.call(ts, "onHeaderClick", p.gridstate, e); }
+ }
+ });
+ }
+ return false;
+ });
+ if (hg) { p.datatype = "local"; $(".ui-jqgrid-titlebar-close", grid.cDiv).trigger("click"); }
+ }
+ } else {
+ $(grid.cDiv).hide();
+ $(grid.cDiv).nextAll("div:visible").first().addClass("ui-corner-top"); // set on top toolbar or toppager or on hDiv
+ }
+ $(grid.hDiv).after(grid.bDiv);
+ grid.eDiv = $("" +
+ //($self0.jqGrid("isBootstrapGuiStyle") ? "×
")[0];
+ $(grid.hDiv).after(grid.eDiv);
+ $(eg)
+ .click(myResizerClickHandler)
+ .dblclick(function (e) { // it's still needed for Firefox
+ var $resizer = $(p.rs),
+ resizerOffset = $resizer.offset(),
+ iColIndex = $resizer.data("idx"),
+ delta = $resizer.data("delta"),
+ cm = p.colModel[iColIndex],
+ pageX = $(this).data("pageX") || $resizer.data("pageX");
+
+ if (pageX == null || cm == null) {
+ return false;
+ }
+ var arPageX = String(pageX).split(";"),
+ pageX1 = parseFloat(arPageX[0]),
+ pageX2 = parseFloat(arPageX[1]);
+ if (arPageX.length === 2 && (Math.abs(pageX1 - pageX2) > 5 || Math.abs(e.pageX - pageX1) > 5 || Math.abs(e.pageX - pageX2) > 5)) {
+ return false;
+ }
+
+ if (feedback.call(ts, "resizeDblClick", iColIndex, cm) &&
+ (resizerOffset.left - 1 <= e.pageX + delta && e.pageX + delta <= resizerOffset.left + $resizer.outerWidth() + 1) && cm.autoResizable) {
+ $j.autoResizeColumn.call($self0, iColIndex);
+ }
+ feedback.call(ts, "afterResizeDblClick", { iCol: iColIndex, cm: cm, cmName: cm.name });
+ return false;
+ });
+ if (!p.pager) {
+ $(grid.cDiv).nextAll("div:visible").filter(":last").addClass(bottomClasses); // set on bottom toolbar or footer (sDiv) or on bDiv
+ }
+ $(".ui-jqgrid-labels", grid.hDiv)
+ .on("selectstart", function () { return false; });
+ ts.formatCol = formatCol;
+ ts.sortData = sortData;
+ ts.updatepager = updatepager;
+ ts.refreshIndex = refreshIndex;
+ ts.addItemDataToColumnIndex = addItemDataToColumnIndex;
+ ts.removeItemDataFromColumnIndex = removeItemDataFromColumnIndex;
+ ts.generateValueFromColumnIndex = function (cmName, separator, delimiter) {
+ var uniqueTexts = $(this).jqGrid("getUniqueValueFromColumnIndex", cmName), v = "", i, len;
+
+ if (uniqueTexts != null) {
+ // convert to format of editoptions.value or searchoptions.value
+ delimiter = delimiter || ";";
+ separator = separator || ":";
+ for (i = 0, len = uniqueTexts.length; i < len; i++) {
+ if (v !== "") {
+ v += delimiter || ";";
+ }
+ v += uniqueTexts[i] + (separator || ":") + uniqueTexts[i];
+ }
+ }
+ return v;
+ };
+ ts.setHeadCheckBox = setHeadCheckBox;
+ ts.fixScrollOffsetAndhBoxPadding = fixScrollOffsetAndhBoxPadding;
+ ts.constructTr = constructTr;
+ ts.formatter = formatter;
+ extend(grid, { populate: populate, emptyRows: emptyRows, beginReq: beginReq, endReq: endReq });
+ ts.addXmlData = readInput;
+ ts.addJSONData = readInput;
+ ts.rebuildRowIndexes = rebuildRowIndexes;
+ ts.grid.cols = ts.rows[0].cells;
+ feedback.call(ts, "onInitGrid");
+
+ // fix to allow to load TreeGrid using datatype:"local", data:mydata instead of treeGrid: true
+ if (p.treeGrid && p.datatype === "local" && p.data != null && p.data.length > 0) {
+ p.datatype = "jsonstring";
+ p.datastr = p.data;
+ p.data = [];
+ }
+
+ populate.call(ts);
+ p.hiddengrid = false;
+ });
+ };
+ var base = $.fn.jqGrid;
+ jgrid.extend({
+ getGridRes: function (defaultPropName) {
+ // The problem is the following: there are already exist some properties of $.jgrid which can be used
+ // to set some defaults of jqGrid. It's: $.jgrid.defaults, $.jgrid.search, $.jgrid.edit, $.jgrid.view, $.jgrid.del, $.jgrid.nav
+ // $.jgrid.formatter, $.jgrid.errors, $.jgrid.col
+ // Existing programs could use the objects to set either language specific settings (which are now moved under locales part)
+ // be language independent. Thus one should combine language specific settings with the user's settings and overwrite the settings
+ // with grid specific settings if the settings exist.
+ //
+ // For example:
+ // p.loadtext (grid option) = "..."
+ // $.jgrid.defaults.loadtext = "........."
+ // p.locales = "en-US",
+ // $.jgrid.locales["en-US"].defaults.loadtext = "Loading...";
+ //
+ // p.edit.addCaption = "Add Invoice"
+ // $.jgrid.edit.addCaption = "Add"
+ // p.locales = "en-US",
+ // $.jgrid.locales["en-US"].edit.addCaption = "Add Record";
+ //
+ // In the case the grid option p.loadtext = "..." need be used. If p.loadtext is not defined then $.jgrid.defaults.loadtext. If
+ // $.jgrid.defaults.loadtext is not defined explicitly by the user, then language settings will be used
+
+ var $t = this[0];
+ if (!$t || !$t.grid || !$t.p) { return null; }
+ // One need get defaultPropName from $.jgrid root first. If no value exist then one should get it from $.jgrid[reg] root
+ var res = jgrid.getRes(locales[$t.p.locale], defaultPropName) || jgrid.getRes(locales["en-US"], defaultPropName),
+ resDef = jgrid.getRes(jgrid, defaultPropName);
+ return typeof res === "object" && res !== null && !$.isArray(res) ?
+ $.extend(true, {}, res, resDef || {}) : // !!! Expensive and can be slow !!!
+ resDef !== undefined ? resDef : res;
+ },
+ getGuiStyles: function (path, jqClasses) {
+ var $t = this instanceof $ && this.length > 0 ? this[0] : this;
+ if (!$t || !$t.grid || !$t.p) { return ""; }
+ var p = $t.p, guiStyle = p.guiStyle || jgrid.defaults.guiStyle || "jQueryUI",
+ guiClasses = jgrid.getRes(jgrid.guiStyles[guiStyle], path), baseGuiStyle;
+ if (guiClasses === undefined) {
+ baseGuiStyle = jgrid.getRes(jgrid.guiStyles[guiStyle], "baseGuiStyle");
+ if (typeof baseGuiStyle === "string") {
+ guiClasses = jgrid.getRes(jgrid.guiStyles[baseGuiStyle], path);
+ }
+ }
+ return jgrid.mergeCssClasses(guiClasses || "", jqClasses || "");
+ },
+ isBootstrapGuiStyle: function () {
+ return $.inArray("ui-jqgrid-bootstrap", $(this).jqGrid("getGuiStyles", "gBox").split(" ")) >= 0;
+ },
+ displayErrorMessage: function (message) {
+ var $t = this instanceof $ && this.length > 0 ? this[0] : this;
+ if (!$t || !$t.grid || !$t.p || !message) { return; }
+ var $errorDiv = $($t.grid.eDiv),
+ $errorSpan = $errorDiv.children(".ui-jqgrid-error");
+
+ $errorSpan.html(message);
+ $errorDiv.show();
+ if ($t.p.errorDisplayTimeout) {
+ setTimeout(function () {
+ $errorSpan.empty();
+ $errorDiv.hide();
+ }, $t.p.errorDisplayTimeout);
+ }
+ },
+ getIconRes: function (path) {
+ var $t = this instanceof $ && this.length > 0 ? this[0] : this;
+ if (!$t || !$t.p) { return ""; }
+
+ var p = $t.p, iconSet = jgrid.icons[p.iconSet],
+ getIcon = function (basePath, path) {
+ var pathParts = path.split("."), root, n = pathParts.length, part, i, classes = [];
+ basePath = typeof basePath === "string" ? jgrid.icons[basePath] : basePath;
+ if (basePath == null) {
+ return ""; // error unknown iconSet
+ }
+ root = basePath;
+ if (root.common) {
+ classes.push(root.common);
+ }
+ for (i = 0; i < n; i++) {
+ part = pathParts[i];
+ if (!part) {
+ break;
+ }
+ root = root[part];
+ if (root === undefined) {
+ if (part === "common") { break; }
+ return ""; // error unknown icon path
+ }
+ if (typeof root === "string") {
+ classes.push(root);
+ break;
+ }
+ if (root != null && root.common) {
+ classes.push(root.common);
+ }
+ }
+ return jgrid.mergeCssClasses.apply(this, classes);
+ };
+
+ if (iconSet == null) {
+ return "";
+ }
+ var classes = getIcon(p.iconSet, path);
+ if (classes === "" && iconSet.baseIconSet != null) {
+ classes = getIcon(iconSet.baseIconSet, path);
+ }
+ return classes || "";
+ },
+ isInCommonIconClass: function (testClass) {
+ var $t = this instanceof $ && this.length > 0 ? this[0] : this;
+ if (!$t || !$t.p) { return ""; }
+
+ var p = $t.p, iconSet = jgrid.icons[p.iconSet];
+ if (iconSet == null) {
+ return false;
+ }
+ var commonClasses = iconSet.common;
+ if (commonClasses === undefined) {
+ if (iconSet.baseIconSet == null) {
+ return false;
+ }
+ iconSet = jgrid.icons[iconSet.baseIconSet];
+ if (iconSet == null) {
+ return false;
+ }
+ commonClasses = iconSet.common;
+ }
+ return typeof commonClasses === "string" && $.inArray(testClass, commonClasses.split(" ")) >= 0;
+ },
+ getUniqueValueFromColumnIndex: function (cmName) {
+ var $t = this[0];
+ if (!$t || !$t.grid) { return null; }
+ var uniqueTexts = [], v = "", id;
+
+ var uniqueValues = $t.p.indexByColumnData[cmName];
+ if (uniqueValues != null) {
+ for (v in uniqueValues) {
+ if (uniqueValues.hasOwnProperty(v)) {
+ for (id in uniqueValues[v]) {
+ if (uniqueValues[v].hasOwnProperty(id)) {
+ v = String(uniqueValues[v][id]); // get the value in the correct case
+ break;
+ }
+ }
+ uniqueTexts.push(v);
+ }
+ }
+ // sort the values
+ if ($t.p.ignoreCase) {
+ if (typeof String.prototype.localeCompare === "undefined") {
+ // IE10 and before
+ uniqueTexts.sort(function (a, b) {
+ var aLowCase = a.toLowerCase(),
+ bLowCase = b.toLowerCase();
+ return (aLowCase === bLowCase) ? 0 : ((aLowCase > bLowCase) ? 1 : -1);
+ });
+ } else {
+ uniqueTexts.sort(function (a, b) {
+ return String(a).toLowerCase().localeCompare(String(b).toLowerCase());
+ });
+ }
+ } else {
+ uniqueTexts.sort();
+ }
+ }
+ return uniqueTexts;
+ },
+ generateDatalistFromColumnIndex: function (cmName) {
+ if (!this[0] || !this[0].grid) { return null; }
+ var uniqueTexts = this.jqGrid("getUniqueValueFromColumnIndex", cmName), i, len,
+ $dataList = $("" + o.caption + " ");
+ var hoverClasses = getGuiStyles.call(this, "states.hover"),
+ ahr = $("
");
+ $(themodalSelector).jqResize(".jqResize", resizeAlso);
+ } else {
+ try {
+ $(mw).resizable({ handles: "se, sw", alsoResize: resizeAlso });
+ } catch (ignore) { }
+ }
+ }
+ if (o.closeOnEscape === true) {
+ $(mw).keydown(function (e) {
+ if (e.which === 27) {
+ var cone = $(themodalSelector).data("onClose") || o.onClose;
+ jgrid.hideModal(themodalSelector, { gb: o.gbox, jqm: o.jqModal, onClose: cone, removemodal: o.removemodal || false, formprop: !o.recreateForm || false, form: o.form || "" });
+ }
+ });
+ }
+ },
+ viewModal: function (selector, o) {
+ o = $.extend(true, {
+ //toTop: false,
+ overlay: 30,
+ modal: false,
+ overlayClass: getGuiStyles.call(this, "overlay"), // "ui-widget-overlay"
+ onShow: jgrid.showModal,
+ onHide: jgrid.closeModal,
+ gbox: "",
+ jqm: true,
+ jqM: true
+ }, jgrid.jqModal || {}, o || {});
+ if ($.fn.jqm && o.jqm === true) {
+ if (o.jqM) {
+ $(selector).attr("aria-hidden", "false").jqm(o).jqmShow();
+ } else {
+ $(selector).attr("aria-hidden", "false").jqmShow();
+ }
+ } else {
+ if (o.gbox !== "") {
+ $(">.jqgrid-overlay", o.gbox).first().show();
+ $(selector).data("gbox", o.gbox);
+ }
+ $(selector).show().attr("aria-hidden", "false");
+ try { $(":input:visible", selector)[0].focus(); } catch (ignore) { }
+ }
+ },
+ info_dialog: function (caption, content, closeButtonText, modalopt) {
+ var $t = this, p = $t.p,
+ mopt = $.extend(true,
+ {
+ width: 290,
+ height: "auto",
+ dataheight: "auto",
+ drag: true,
+ resize: false,
+ left: 250,
+ top: 170,
+ zIndex: 1000,
+ jqModal: true,
+ modal: false,
+ closeOnEscape: true,
+ align: "center",
+ buttonalign: "center",
+ buttons: []
+ // {text:"textbutt", id:"buttid", onClick : function(){...}}
+ // if the id is not provided we set it like info_button_+ the index in the array - i.e info_button_0,info_button_1...
+ },
+ jgrid.jqModal || {},
+ p != null ? p.jqModal || {} : {},
+ { caption: "" + caption + " " },
+ modalopt || {}),
+ jm = mopt.jqModal;
+
+ if ($.fn.jqm && !jm) { jm = false; }
+ // in case there is no jqModal
+ var buttstr = "", i, hoverClasses = getGuiStyles.call($t, "states.hover");
+ if (mopt.buttons.length > 0) {
+ for (i = 0; i < mopt.buttons.length; i++) {
+ if (mopt.buttons[i].id === undefined) { mopt.buttons[i].id = "info_button_" + i; }
+ buttstr += jgrid.builderFmButon.call($t, mopt.buttons[i].id, mopt.buttons[i].text);
+ }
+ }
+ var dh = isNaN(mopt.dataheight) ? mopt.dataheight : mopt.dataheight + "px",
+ cn = "text-align:" + mopt.align + ";",
+ $dlg = $("#info_dialog"),
+ cnt = "";
+ cnt += "
" + content + "
";
+ if (closeButtonText || buttstr !== "") {
+ cnt += "
" +
+ (closeButtonText ? jgrid.builderFmButon.call($t, "closedialog", closeButtonText) : "") + buttstr + "
";
+ }
+ cnt += "
"), elem, $elem,
+ $stable = $(""),
+ $tds = $stable.children("tbody").children("tr").children("td"),
+ $tdOper = $tds.eq(0),
+ $tdInput = $tds.eq(1),
+ $tdClear = $tds.eq(2);
+ if (this.hidden === true) { $th.css("display", "none"); }
+ this.search = this.search === false ? false : true;
+ if (this.stype === undefined) { this.stype = "text"; }
+ soptions = $.extend({ mode: mode, name: cm.name, cm: cm, iCol: ci, id: getId(cm.name) }, searchoptions);
+ if (this.search) {
+ if (o.searchOperators) {
+ if (p.search && currentFilters[this.name] != null) {
+ so = currentFilters[this.name].op;
+ } else {
+ so = (soptions.sopt) ? soptions.sopt[0] : (cm.stype === "select" || cm.stype === "checkbox") ? "eq" : o.defaultSearch;
+ }
+ for (i = 0; i < odata.length; i++) {
+ if (odata[i].oper === so) {
+ sot = o.operands[so] || "";
+ break;
+ }
+ }
+ if (sot === undefined && customSortOperations != null) {
+ var customOp;
+ for (customOp in customSortOperations) {
+ if (customSortOperations.hasOwnProperty(customOp) && customOp === so) {
+ sot = customSortOperations[customOp].operand;
+ break;
+ //soptions.searchtitle = customSortOperations[customOp].title;
+ }
+ }
+ }
+ if (sot === undefined) { sot = "="; }
+ $tdOper.append("" + sot + " ");
+ }
+ $tdOper.data("colindex", ci);
+ if (soptions.sopt == null || soptions.sopt.length === 1) {
+ $tdOper.hide();
+ }
+ if (p.search && currentFilters[this.name] != null) {
+ soptions.defaultValue = currentFilters[this.name].data;
+ }
+ if (soptions.clearSearch === undefined) {
+ soptions.clearSearch = this.stype === "text" ? true : false;
+ }
+ if (soptions.clearSearch) {
+ var csv = $.isFunction(o.resetTitle) ?
+ o.resetTitle.call($t, {
+ options: o,
+ cm: cm,
+ cmName: cm.name,
+ iCol: ci
+ }) :
+ (getRes("search.resetTitle") || "Clear Search Value") + " " + jgrid.stripHtml(p.colNames[ci]);
+ $tdClear.append("" + o.resetIcon + " ... instead of ... )
+ // and the multiple attribute will be assigned via soptions.attr (attr: { multiple: "multiple" }).
+ // One will have non-multiple select initially, where the first element will be automatically selected.
+ // After assigning the attribute multiple="multiple" the select will be able to have no selected elements,
+ // but it will be too late. To fix the case we will unselect the first element in the special case.
+ $select[0].options[$select[0].selectedIndex].selected = false;
+ }
+
+ if (soptions1.defaultValue !== undefined) { $select.val(soptions1.defaultValue); }
+ // preserve autoserch
+ jgrid.bindEv.call($t, $select[0], soptions1);
+ jgrid.fullBoolFeedback.call($t, soptions1.selectFilled, "jqGridSelectFilled", {
+ elem: $select[0],
+ options: soptions1,
+ cm: cm1,
+ cmName: cm1.name,
+ iCol: iCol1,
+ mode: mode
+ });
+ if (o.autosearch === true) {
+ $select.change(function () {
+ triggerToolbar();
+ return false;
+ });
+ }
+ }
+ }, jgrid.ajaxOptions, p.ajaxSelectOptions || {}));
+ } else {
+ var oSv, sep, delim;
+ if (cm.searchoptions) {
+ oSv = searchoptions.value === undefined ? editoptions.value || "" : searchoptions.value;
+ sep = searchoptions.separator === undefined ? editoptions.separator || ":" : searchoptions.separator;
+ delim = searchoptions.delimiter === undefined ? editoptions.delimiter || ";" : searchoptions.delimiter;
+ } else if (cm.editoptions) {
+ oSv = editoptions.value === undefined ? "" : editoptions.value;
+ sep = editoptions.separator === undefined ? ":" : editoptions.separator;
+ delim = editoptions.delimiter === undefined ? ";" : editoptions.delimiter;
+ }
+ if (searchoptions.generateValue && p.indexByColumnData[cm.name] != null) {
+ oSv = $t.generateValueFromColumnIndex(cm.name, sep, delim);
+ }
+ if (oSv) {
+ elem = document.createElement("select");
+ elem.style.width = "100%";
+ $elem = $(elem).attr({
+ name: cm.index || cm.name,
+ role: "search",
+ id: getId(cm.name),
+ "aria-describedby": p.id + "_" + cm.name
+ });
+ if (soptions.attr) { $elem.attr(soptions.attr); }
+ var isNoFilterValueExist = jgrid.fillSelectOptions(
+ elem,
+ oSv,
+ sep,
+ delim,
+ soptions.attr != null && soptions.attr.multiple
+ );
+ if (!isNoFilterValueExist && typeof soptions.noFilterText === "string") {
+ var ov = document.createElement("option");
+ ov.value = "";
+ ov.innerHTML = soptions.noFilterText;
+ ov.selected = true;
+ $elem.prepend(ov);
+ }
+ if (soptions.defaultValue !== undefined) { $elem.val(soptions.defaultValue); }
+ $elem.addClass(dataFieldClass);
+ //bindEv.call($t, elem, soptions);
+ bindings.push({ elem: elem, options: soptions });
+ $tdInput.append(elem);
+ jgrid.fullBoolFeedback.call($t, soptions.selectFilled, "jqGridSelectFilled", {
+ elem: elem,
+ options: cm.searchoptions || editoptions,
+ cm: cm,
+ cmName: cm.name,
+ iCol: ci,
+ mode: mode
+ });
+ if (o.autosearch === true) {
+ $elem.change(function () {
+ triggerToolbar();
+ return false;
+ });
+ }
+ }
+ }
+ break;
+ case "text":
+ $elem = $("", { role: "row" }).addClass("ui-jqgrid-labels");
+ var headers = grid.headers;
+ for (i = 0, l = headers.length; i < l; i++) {
+ hc = cm[i].hidden ? "none" : "";
+ $th = $(headers[i].el)
+ .width(headers[i].width)
+ .css("display", hc);
+ try {
+ $th.removeAttr("rowSpan");
+ } catch (rs) {
+ //IE 6/7
+ $th.attr("rowSpan", 1);
+ }
+ $tr.append($th);
+ $resizing = $th.children("span.ui-jqgrid-resize");
+ if ($resizing.length > 0) {// resizable column
+ $resizing[0].style.height = "";
+ }
+ $th.children("div")[0].style.top = "";
+ }
+ $(thead).children("tr.ui-jqgrid-labels").remove();
+ $(thead).prepend($tr);
+
+ if (nullHeader === true) {
+ $($t).jqGrid("setGridParam", { "groupHeader": null });
+ }
+ });
+ },
+ setGroupHeaders: function (o) {
+ o = $.extend({
+ useColSpanStyle: false,
+ applyLabelClasses: true,
+ groupHeaders: []
+ }, o || {});
+ return this.each(function () {
+ this.p.groupHeader = o;
+ var ts = this, i, cmi, skip = 0, $tr, $colHeader, th, $th, thStyle, iCol, cghi, numberOfColumns, titleText, cVisibleColumns,
+ p = ts.p, colModel = p.colModel, cml = colModel.length, ths = ts.grid.headers, $theadInTable, thClasses,
+ $htable = $("table.ui-jqgrid-htable", ts.grid.hDiv), isCellClassHidden = jgrid.isCellClassHidden,
+ $trLabels = $htable.children("thead").children("tr.ui-jqgrid-labels"),
+ $trLastWithLabels = $trLabels.last().addClass("jqg-second-row-header"),
+ $thead = $htable.children("thead"),
+ $firstHeaderRow = $htable.find(".jqg-first-row-header");
+ if ($firstHeaderRow[0] === undefined) {
+ $firstHeaderRow = $(" ", { role: "row", "aria-hidden": "true" }).addClass("jqg-first-row-header").css("height", "auto");
+ } else {
+ $firstHeaderRow.empty();
+ }
+ var inColumnHeader = function (cmName, columnHeaders) {
+ var j;
+ for (j = 0; j < columnHeaders.length; j++) {
+ if (columnHeaders[j].startColumnName === cmName) {
+ return columnHeaders[j];
+ }
+ }
+ return 0; // falsy value
+ };
+
+ $(ts).prepend($thead);
+ $tr = $(" ", { role: "row" }).addClass("ui-jqgrid-labels jqg-third-row-header");
+ for (i = 0; i < cml; i++) {
+ th = ths[i].el;
+ $th = $(th);
+ cmi = colModel[i];
+ // build the next cell for the first header row
+ // ??? cmi.hidden || isCellClassHidden(cmi.classes) || $th.is(":hidden")
+ thStyle = { height: "0", width: ths[i].width + "px", display: (cmi.hidden ? "none" : "") };
+ $("", { role: "gridcell" }).css(thStyle).addClass("ui-first-th-" + p.direction + (o.applyLabelClasses ? " " + (cmi.labelClasses || "") : "")).appendTo($firstHeaderRow);
+
+ th.style.width = ""; // remove unneeded style
+ thClasses = getGuiStyles.call(ts, "colHeaders", "ui-th-column-header ui-th-" + p.direction + " " + (o.applyLabelClasses ? cmi.labelClasses || "" : ""));
+ cghi = inColumnHeader(cmi.name, o.groupHeaders);
+ if (cghi) {
+ numberOfColumns = cghi.numberOfColumns;
+ titleText = cghi.titleText;
+
+ // caclulate the number of visible columns from the next numberOfColumns columns
+ for (cVisibleColumns = 0, iCol = 0; iCol < numberOfColumns && (i + iCol < cml); iCol++) {
+ if (!colModel[i + iCol].hidden && !isCellClassHidden(colModel[i + iCol].classes)) {
+ cVisibleColumns++;
+ }
+ }
+
+ // The next numberOfColumns headers will be moved in the next row
+ // in the current row will be placed the new column header with the titleText.
+ // The text will be over the cVisibleColumns columns
+ $colHeader = $(" ")
+ .addClass(thClasses)
+ .html(titleText || " ");
+ if (cVisibleColumns > 0) {
+ $colHeader.attr("colspan", String(cVisibleColumns));
+ }
+ if (p.headertitles) {
+ $colHeader.attr("title", $colHeader.text());
+ }
+ // hide if not a visible cols
+ if (cVisibleColumns === 0) {
+ $colHeader.hide();
+ }
+
+ $th.before($colHeader); // insert new column header before the current
+ $tr.append(th); // move the current header in the next row
+
+ // set the counter of headers which will be moved in the next row
+ skip = numberOfColumns - 1;
+ } else {
+ if (skip === 0) {
+ if (o.useColSpanStyle) {
+ // expand the header height to two rows
+ $th.attr("rowspan", $trLabels.length + 1); // consider to use ($th.attr("rowspan") || 1) instead of $trLabels.length
+ } else {
+ $(" ")
+ .addClass(thClasses)
+ .css({ "display": cmi.hidden ? "none" : "", "border-top": "0 none" })
+ .insertBefore($th);
+ $tr.append(th);
+ }
+ } else {
+ // move the header to the next row
+ $tr.append(th);
+ skip--;
+ }
+ }
+ }
+ $theadInTable = $(ts).children("thead");
+ $theadInTable.prepend($firstHeaderRow);
+ $tr.insertAfter($trLastWithLabels);
+ $htable.prepend($theadInTable);
+
+ $(ts).triggerHandler("jqGridAfterSetGroupHeaders");
+ });
+ },
+ getNumberOfFrozenColumns: function () {
+ var $t = this;
+ if ($t.length === 0) {
+ return 0;
+ }
+ $t = $t[0];
+ var colModel = $t.p.colModel, len = colModel.length, maxfrozen = -1, i;
+ // get the max index of frozen col
+ for (i = 0; i < len; i++) {
+ // from left, no breaking frozen
+ if (colModel[i].frozen !== true) {
+ break;
+ }
+ maxfrozen = i;
+ }
+ return maxfrozen + 1;
+ },
+ setFrozenColumns: function (o) {
+ o = o || {};
+ return this.each(function () {
+ var $t = this, $self = $($t), p = $t.p, grid = $t.grid;
+ if (!grid || p == null || p.frozenColumns === true) { return; }
+ var cm = p.colModel, i, len = cm.length, maxfrozen = -1, frozen = false, frozenIds = [], $colHeaderRow,// nonFrozenIds = [],
+ tid = jqID(p.id), // one can use p.idSel and remove "#"
+ hoverClasses = getGuiStyles.call($t, "states.hover");
+
+ // TODO treeGrid and grouping Support
+ // TODO: allow to edit columns AFTER frozen columns
+ if (p.subGrid === true || p.treeGrid === true || p.scroll) {
+ return;
+ }
+
+ // get the max index of frozen col
+ for (i = 0; i < len; i++) {
+ // from left, no breaking frozen
+ if (cm[i].frozen !== true) {
+ break;
+ //nonFrozenIds.push("#jqgh_" + tid + "_" + jqID(cm[i].name));
+ }
+ frozen = true;
+ maxfrozen = i;
+ frozenIds.push("#jqgh_" + tid + "_" + jqID(cm[i].name));
+ }
+ if (p.sortable) {
+ $colHeaderRow = $(grid.hDiv).find(".ui-jqgrid-htable .ui-jqgrid-labels");
+ try {
+ $colHeaderRow.sortable("destroy");
+ } catch (ignore) { }
+ $self.jqGrid("setGridParam", {
+ sortable: {
+ options: {
+ items: frozenIds.length > 0 ?
+ ">th:not(:has(" + frozenIds.join(",") + "),:hidden)" :
+ ">th:not(:hidden)"
+ }
+ }
+ });
+ $self.jqGrid("sortableColumns", $colHeaderRow);
+ }
+ if (maxfrozen >= 0 && frozen) {
+ var top = p.caption ? $(grid.cDiv).outerHeight() : 0,
+ hth = $(".ui-jqgrid-htable", p.gView).height();
+ //headers
+ if (p.toppager) {
+ top = top + $(grid.topDiv).outerHeight();
+ }
+ if (p.toolbar[0] === true) {
+ if (p.toolbar[1] !== "bottom") {
+ top = top + $(grid.uDiv).outerHeight();
+ }
+ }
+ grid.fhDiv = $("
");
+ grid.fbDiv = $("
");
+ $(p.gView).append(grid.fhDiv);
+ var htbl = $(".ui-jqgrid-htable", p.gView).clone(true),
+ tHeadRows = htbl[0].tHead.rows;
+ // groupheader support - only if useColSpanstyle is false
+ if (p.groupHeader) {
+ // TODO: remove all th which corresponds non-frozen columns. One can identify there by id
+ // for example. Consider to use name attribute of th on column headers. It simplifies
+ // identifying of the columns.
+ $(tHeadRows[0].cells).filter(":gt(" + maxfrozen + ")").remove();
+ $(tHeadRows).filter(".jqg-third-row-header").each(function () {
+ $(this).children("th[id]")
+ .each(function () {
+ var id = $(this).attr("id"), colName;
+ if (id && id.substr(0, $t.id.length + 1) === $t.id + "_") {
+ colName = id.substr($t.id.length + 1);
+ if (p.iColByName[colName] > maxfrozen) {
+ $(this).remove();
+ }
+ }
+ });
+ });
+ var swapfroz = -1, fdel = -1, cs, rs;
+ // TODO: test carefully processing of hidden columns
+ $(tHeadRows).filter(".jqg-second-row-header").children("th").each(function () {
+ cs = parseInt($(this).attr("colspan") || 1, 10);
+ rs = parseInt($(this).attr("rowspan") || 1, 10);
+ if (rs > 1) {
+ swapfroz++;
+ fdel++;
+ } else if (cs) {
+ swapfroz = swapfroz + cs;
+ fdel++;
+ }
+ if (swapfroz === maxfrozen) {
+ return false;
+ }
+ });
+ if (swapfroz !== maxfrozen) {
+ fdel = maxfrozen;
+ }
+ $(tHeadRows).filter(".jqg-second-row-header,.ui-search-toolbar").each(function () {
+ $(this).children(":gt(" + fdel + ")").remove();
+ });
+ } else {
+ $(tHeadRows).each(function () {
+ $(this).children(":gt(" + maxfrozen + ")").remove();
+ });
+ }
+ // htable, bdiv and ftable uses table-layout:fixed; style
+ // to make it working one have to set ANY width value on table.
+ // The value of the width will be ignored, the sum of widths
+ // of the first column will be used as the width of tables
+ // and all columns will have the same width like the first row.
+ // We set below just width=1 of the tables.
+ $(htbl).width(1);
+ // resizing stuff
+ $(grid.fhDiv).append(htbl)
+ .scroll(function () {
+ // the fhDiv can be scrolled because of tab keyboard navigation
+ // we prevent horizontal scrolling of fhDiv
+ this.scrollLeft = 0;
+ });
+ if (p.footerrow) {
+ var hbd = $(".ui-jqgrid-bdiv", p.gView).height();
+
+ grid.fsDiv = $("
");
+ $(p.gView).append(grid.fsDiv);
+ var ftbl = $(".ui-jqgrid-ftable", p.gView).clone(true);
+ $("tr", ftbl).each(function () {
+ $("td:gt(" + maxfrozen + ")", this).remove();
+ });
+ $(ftbl).width(1);
+ $(grid.fsDiv).append(ftbl);
+ }
+
+ // data stuff
+ //TODO support for setRowData
+ $(p.gView).append(grid.fbDiv);
+ $(grid.bDiv).scroll(function () {
+ $(grid.fbDiv).scrollTop($(this).scrollTop());
+ });
+ $(grid.fbDiv).on("mousewheel.setFrozenColumns DOMMouseScroll.setFrozenColumns", function (e) {
+ grid.bDiv.scrollTop += $.isFunction(o.mouseWheel) ?
+ o.mouseWheel.call($t, e) :
+ e.type === "mousewheel" ?
+ -e.originalEvent.wheelDelta / 10 :
+ e.originalEvent.detail * 6;
+ });
+ if (p.hoverrows === true) {
+ $(p.idSel).off("mouseover.jqGrid mouseout.jqGrid");
+ }
+ var safeHeightSet = function ($elem, newHeight) {
+ var height = $elem.height();
+ if (Math.abs(height - newHeight) >= 1 && newHeight > 0) {
+ $elem.height(newHeight);
+ height = $elem.height();
+ if (Math.abs(newHeight - height) >= 1) {
+ $elem.height(newHeight + Math.round((newHeight - height)));
+ }
+ }
+ },
+ safeWidthSet = function ($elem, newWidth) {
+ var width = $elem.width();
+ if (Math.abs(width - newWidth) >= 1) {
+ $elem.width(newWidth);
+ width = $elem.width();
+ if (Math.abs(newWidth - width) >= 1) {
+ $elem.width(newWidth + Math.round((newWidth - width)));
+ }
+ }
+ },
+ fixDiv = function ($hDiv, hDivBase, iRowStart, iRowEnd) {
+ var iRow, n, $frozenRows, $rows, $row, $frozenRow, posFrozenTop, height, newHeightFrozen, td,
+ posTop = $(hDivBase).position().top, frozenTableTop, tableTop, cells;
+ if ($hDiv != null && $hDiv.length > 0) {
+ $hDiv[0].scrollTop = hDivBase.scrollTop;
+ $hDiv.css(p.direction === "rtl" ?
+ { top: posTop, right: 0 } :
+ { top: posTop, left: 0 }
+ );
+ // first try with thead for the hdiv
+ $frozenRows = $hDiv.children("table").children("thead").children("tr");
+ $rows = $(hDivBase).children("div").children("table").children("thead").children("tr");
+ if ($rows.length === 0 && $hDiv.children("table").length > 0) {
+ // then use tbody for bdiv
+ $frozenRows = $($hDiv.children("table")[0].rows);
+ $rows = $($(hDivBase).children("div").children("table")[0].rows);
+ }
+ n = Math.min($frozenRows.length, $rows.length);
+ frozenTableTop = n > 0 ? $($frozenRows[0]).position().top : 0;
+ tableTop = n > 0 ? $($rows[0]).position().top : 0; // typically 0
+ if (iRowStart >= 0) { // negative iRowStart means no changing of the height of individual rows
+ if (iRowEnd >= 0) { // negative iRowEnd means all rows
+ n = Math.min(iRowEnd + 1, n);
+ }
+ for (iRow = iRowStart; iRow < n; iRow++) {
+ // but after that one have to verify all scenarios
+ $row = $($rows[iRow]);
+ if ($row.css("display") !== "none" && $row.is(":visible")) {
+ posTop = $row.position().top;
+ $frozenRow = $($frozenRows[iRow]);
+ posFrozenTop = $frozenRow.position().top;
+ height = $row.height();
+ if (p.groupHeader != null && p.groupHeader.useColSpanStyle) {
+ cells = $row[0].cells;
+ for (i = 0; i < cells.length; i++) { // maxfrozen
+ td = cells[i];
+ if (td != null && td.nodeName.toUpperCase() === "TH") {
+ height = Math.max(height, $(td).height());
+ }
+ }
+ }
+ newHeightFrozen = height + (posTop - tableTop) + (frozenTableTop - posFrozenTop);
+ safeHeightSet($frozenRow, newHeightFrozen);
+ }
+ }
+ }
+ safeHeightSet($hDiv, hDivBase.clientHeight);
+ }
+ },
+ /** @const */
+ resizeAll = {
+ resizeDiv: true,
+ resizedRows: {
+ iRowStart: 0,
+ iRowEnd: -1 // -1 means "till the end"
+ }
+ },
+ /** @const */
+ fullResize = {
+ header: resizeAll,
+ resizeFooter: true,
+ body: resizeAll
+ };
+
+ $self.on("jqGridAfterGridComplete.setFrozenColumns", function () {
+ $(p.idSel + "_frozen").remove();
+ $(grid.fbDiv).height(grid.hDiv.clientHeight);
+ // clone with data and events !!!
+ var $frozenBTable = $(this).clone(true),
+ frozenRows = $frozenBTable[0].rows,
+ rows = $self[0].rows;
+ $(frozenRows).filter("tr[role=row]").each(function () {
+ $(this.cells).filter("td[role=gridcell]:gt(" + maxfrozen + ")").remove();
+ /*if (this.id) {
+ $(this).attr("id", this.id + "_frozen");
+ }*/
+ });
+ grid.fbRows = frozenRows;
+
+ $frozenBTable.width(1).attr("id", p.id + "_frozen");
+ $frozenBTable.appendTo(grid.fbDiv);
+ if (p.hoverrows === true) {
+ var hoverRows = function (tr, method, additionalRows) {
+ $(tr)[method](hoverClasses);
+ $(additionalRows[tr.rowIndex])[method](hoverClasses);
+ };
+ $(frozenRows).filter(".jqgrow").hover(
+ function () {
+ hoverRows(this, "addClass", rows);
+ },
+ function () {
+ hoverRows(this, "removeClass", rows);
+ }
+ );
+ $(rows).filter(".jqgrow").hover(
+ function () {
+ hoverRows(this, "addClass", frozenRows);
+ },
+ function () {
+ hoverRows(this, "removeClass", frozenRows);
+ }
+ );
+ }
+ fixDiv(grid.fhDiv, grid.hDiv, 0, -1);
+ fixDiv(grid.fbDiv, grid.bDiv, 0, -1);
+ if (grid.sDiv) { fixDiv(grid.fsDiv, grid.sDiv, 0, -1); }
+ });
+ var myResize = function (resizeOptions) {
+ $(grid.fbDiv).scrollTop($(grid.bDiv).scrollTop());
+ // TODO: the width of all column headers can be changed
+ // so one should recalculate frozenWidth in other way.
+ if (resizeOptions.header.resizeDiv) {
+ fixDiv(grid.fhDiv, grid.hDiv, resizeOptions.header.resizedRows.iRowStart, resizeOptions.header.resizedRows.iRowEnd);
+ }
+ if (resizeOptions.body.resizeDiv) {
+ fixDiv(grid.fbDiv, grid.bDiv, resizeOptions.body.resizedRows.iRowStart, resizeOptions.body.resizedRows.iRowEnd);
+ }
+ if (resizeOptions.resizeFooter && grid.sDiv && resizeOptions.resizeFooter) {
+ fixDiv(grid.fsDiv, grid.sDiv, 0, -1);
+ }
+ var frozenWidth = grid.fhDiv[0].clientWidth;
+ if (resizeOptions.header.resizeDiv && grid.fhDiv != null && grid.fhDiv.length >= 1) {
+ safeHeightSet($(grid.fhDiv), grid.hDiv.clientHeight);
+ }
+ if (resizeOptions.body.resizeDiv && grid.fbDiv != null && grid.fbDiv.length > 0) {
+ safeWidthSet($(grid.fbDiv), frozenWidth);
+ }
+ if (resizeOptions.resizeFooter && grid.fsDiv != null && grid.fsDiv.length >= 0) {
+ safeWidthSet($(grid.fsDiv), frozenWidth);
+ }
+ };
+ $(p.gBox).on("resizestop.setFrozenColumns", function () {
+ setTimeout(function () {
+ myResize(fullResize);
+ }, 50);
+ });
+ $self.on("jqGridInlineEditRow.setFrozenColumns jqGridInlineAfterRestoreRow.setFrozenColumns jqGridInlineAfterSaveRow.setFrozenColumns jqGridAfterEditCell.setFrozenColumns jqGridAfterRestoreCell.setFrozenColumns jqGridAfterSaveCell.setFrozenColumns jqGridResizeStop.setFrozenColumns", function (e, rowid) {
+ // TODO: probably one should handle additional events like afterSetRow
+ // and remove jqGridInlineAfterSaveRow and jqGridInlineAfterRestoreRow
+ var iRow = $self.jqGrid("getInd", rowid);
+ myResize({
+ header: {
+ resizeDiv: false, // don't recalculate the position and the height of hDiv
+ resizedRows: {
+ iRowStart: -1, // -1 means don't recalculate heights or rows
+ iRowEnd: -1
+ }
+ },
+ resizeFooter: true, // recalculate the position and the height of sDiv
+ body: {
+ resizeDiv: true, // recalculate the position and the height of bDiv
+ resizedRows: {
+ // recalculate the height of only one row inside of bDiv
+ iRowStart: iRow,
+ iRowEnd: iRow
+ }
+ }
+ });
+ });
+ $self.on("jqGridResizeStop.setFrozenColumns", function () {
+ myResize(fullResize);
+ });
+ $self.on("jqGridResetFrozenHeights.setFrozenColumns", function (e, o) {
+ myResize(o || fullResize);
+ });
+ if (!grid.hDiv.loading) {
+ setTimeout(function () {
+ $self.triggerHandler("jqGridAfterGridComplete");
+ }, 0);
+ }
+ p.frozenColumns = true;
+ }
+ });
+ },
+ destroyFrozenColumns: function () {
+ return this.each(function () {
+ var $t = this, $self = $($t), grid = $t.grid, p = $t.p, tid = jqID(p.id);
+ if (!grid) { return; }
+ if (p.frozenColumns === true) {
+ $(grid.fhDiv).remove();
+ $(grid.fbDiv).off(".setFrozenColumns");
+ $(grid.fbDiv).remove();
+ grid.fhDiv = null;
+ grid.fbDiv = null;
+ grid.fbRows = null;
+ if (p.footerrow) {
+ $(grid.fsDiv).remove();
+ grid.fsDiv = null;
+ }
+ $self.off(".setFrozenColumns");
+ if (p.hoverrows === true) {
+ var ptr, hoverClasses = getGuiStyles.call($t, "states.hover");
+ $self.on("mouseover.jqGrid", function (e) {
+ ptr = $(e.target).closest("tr.jqgrow");
+ if ($(ptr).attr("class") !== "ui-subgrid") {
+ $(ptr).addClass(hoverClasses);
+ }
+ }).on("mouseout.jqGrid", function (e) {
+ ptr = $(e.target).closest("tr.jqgrow");
+ $(ptr).removeClass(hoverClasses);
+ });
+ }
+ p.frozenColumns = false;
+ if (p.sortable) {
+ var $colHeaderRow = $(grid.hDiv).find(".ui-jqgrid-htable .ui-jqgrid-labels");
+ $colHeaderRow.sortable("destroy");
+ $self.jqGrid("setGridParam", {
+ sortable: {
+ options: {
+ items: ">th:not(:has(#jqgh_" + tid + "_cb" + ",#jqgh_" + tid + "_rn" + ",#jqgh_" + tid + "_subgrid),:hidden)"
+ }
+ }
+ });
+ $self.jqGrid("sortableColumns", $colHeaderRow);
+ }
+ }
+ });
+ }
+ });
+ // end module grid.custom
+
+ /**
+ * jqFilter jQuery jqGrid filter addon.
+ * Copyright (c) 2011-2014, Tony Tomov, tony@trirand.com
+ * Copyright (c) 2014-2017, Oleg Kiriljuk, oleg.kiriljuk@ok-soft-gmbh.com
+ * Dual licensed under the MIT and GPL licenses
+ * http://www.opensource.org/licenses/mit-license.php
+ * http://www.gnu.org/licenses/gpl-2.0.html
+ *
+ * The work is inspired from this Stefan Pirvu
+ * http://www.codeproject.com/KB/scripting/json-filtering.aspx
+ *
+ * The filter uses JSON entities to hold filter rules and groups. Here is an example of a filter:
+
+ { "groupOp": "AND",
+ "groups" : [
+ { "groupOp": "OR",
+ "rules": [
+ { "field": "name", "op": "eq", "data": "England" },
+ { "field": "id", "op": "le", "data": "5"}
+ ]
+ }
+ ],
+ "rules": [
+ { "field": "name", "op": "eq", "data": "Romania" },
+ { "field": "id", "op": "le", "data": "1"}
+ ]
+ }
+ */
+ // begin module grid.filter
+ $.fn.jqFilter = function (arg) {
+ if (typeof arg === "string") {
+ var fn = $.fn.jqFilter[arg];
+ if (!fn) {
+ throw ("jqFilter - No such method: " + arg);
+ }
+ var args = $.makeArray(arguments).slice(1);
+ return fn.apply(this, args);
+ }
+
+ var p = $.extend(true, {
+ filter: null,
+ columns: [],
+ onChange: null,
+ afterRedraw: null,
+ error: false,
+ errmsg: "",
+ errorcheck: true,
+ showQuery: true,
+ sopt: null,
+ ops: [],
+ operands: null,
+ numopts: ["eq", "ne", "lt", "le", "gt", "ge", "nu", "nn", "in", "ni"],
+ stropts: ["eq", "ne", "bw", "bn", "ew", "en", "cn", "nc", "nu", "nn", "in", "ni"],
+ strarr: ["text", "string", "blob"],
+ groupOps: [{ op: "AND", text: "AND" }, { op: "OR", text: "OR" }],
+ groupButton: true,
+ ruleButtons: true,
+ direction: "ltr"
+ }, jgrid.filter, arg || {});
+ return this.each(function () {
+ if (this.filter) { return; }
+ this.p = p;
+ // setup filter in case if they is not defined
+ if (p.filter === null || p.filter === undefined) {
+ p.filter = {
+ groupOp: p.groupOps[0].op,
+ rules: [],
+ groups: []
+ };
+ }
+ var iColumn, len = p.columns.length, cl, isIE = /msie/i.test(navigator.userAgent) && !window.opera,
+ isFunction = $.isFunction,
+ fatalErrorFunction = jgrid.defaults != null && isFunction(jgrid.defaults.fatalError) ? jgrid.defaults.fatalError : alert,
+ getGrid = function () {
+ return $("#" + jgrid.jqID(p.id))[0] || null;
+ },
+ getGuiStyles = function (path, jqClasses) {
+ return $(getGrid()).jqGrid("getGuiStyles", path, jqClasses || "");
+ },
+ getRes = function (property) {
+ return $(getGrid()).jqGrid("getGridRes", "search." + property);
+ },
+ getCmInfo = function (cmName) {
+ // the function convert column name or advanced property name to
+ // object with properties { cm: , iCol: }
+ var $t = getGrid(), iCol = $t.p.iColByName[cmName]; //iPropByName
+ if (iCol !== undefined) {
+ return { cm: $t.p.colModel[iCol], iCol: iCol };
+ }
+ iCol = $t.p.iPropByName[cmName];
+ if (iCol !== undefined) {
+ return { cm: $t.p.additionalProperties[iCol], iCol: iCol, isAddProp: true };
+ }
+ return { cm: null, iCol: -1 };
+ },
+ errorClass = getGuiStyles("states.error"),
+ dialogContentClass = getGuiStyles("dialog.content");
+
+ // translating the options
+ p.initFilter = $.extend(true, {}, p.filter);
+
+ // set default values for the columns if they are not set
+ if (!len) { return; }
+ for (iColumn = 0; iColumn < len; iColumn++) {
+ cl = p.columns[iColumn];
+ if (cl.stype) {
+ // grid compatibility
+ cl.inputtype = cl.stype;
+ } else if (!cl.inputtype) {
+ cl.inputtype = "text";
+ }
+ if (cl.sorttype) {
+ // grid compatibility
+ cl.searchtype = cl.sorttype;
+ } else if (!cl.searchtype) {
+ cl.searchtype = "string";
+ }
+ if (cl.hidden === undefined) {
+ // jqGrid compatibility
+ cl.hidden = false;
+ }
+ if (!cl.label) {
+ cl.label = cl.name;
+ }
+ cl.cmName = cl.name;
+ if (cl.index) {
+ cl.name = cl.index;
+ }
+ if (!cl.hasOwnProperty("searchoptions")) {
+ cl.searchoptions = {};
+ }
+ if (!cl.hasOwnProperty("searchrules")) {
+ cl.searchrules = {};
+ }
+
+ }
+ if (p.showQuery) {
+ $(this).append("");
+ }
+ /*
+ *Perform checking.
+ *
+ */
+ var checkData = function (val, colModelItem) {
+ var ret = [true, ""], $t = getGrid();
+ if (isFunction(colModelItem.searchrules)) {
+ ret = colModelItem.searchrules.call($t, val, colModelItem);
+ } else if (jgrid && jgrid.checkValues) {
+ try {
+ ret = jgrid.checkValues.call($t, val, -1, colModelItem.searchrules, colModelItem.label);
+ } catch (ignore) { }
+ }
+ if (ret && ret.length && ret[0] === false) {
+ p.error = !ret[0];
+ p.errmsg = ret[1];
+ }
+ };
+ /* moving to common
+ randId = function() {
+ return Math.floor(Math.random()*10000).toString();
+ };
+ */
+
+ this.onchange = function () {
+ // clear any error
+ p.error = false;
+ p.errmsg = "";
+ return isFunction(p.onChange) ? p.onChange.call(getGrid(), p, this) : false;
+ };
+ /*
+ * Redraw the filter every time when new field is added/deleted
+ * and field is changed
+ */
+ this.reDraw = function () {
+ $("table.group:first", this).remove();
+ var t = this.createTableForGroup(p.filter, null);
+ $(this).append(t);
+ if (isFunction(p.afterRedraw)) {
+ p.afterRedraw.call(getGrid(), p, this);
+ }
+ };
+ /**
+ * Creates a grouping data for the filter
+ * @param group - object
+ * @param parentgroup - object
+ */
+ this.createTableForGroup = function (group, parentgroup) {
+ var that = this, i;
+ // this table will hold all the group (tables) and rules (rows)
+ var table = $(""), align = "left";
+ // create error message row
+ if (p.direction === "rtl") {
+ align = "right";
+ table.attr("dir", "rtl");
+ }
+ if (parentgroup === null) {
+ table.append(" " + that.p.groupOps[i].text + " ";
+ }
+
+ groupOpSelect.append(str)
+ .on("change", function () {
+ group.groupOp = $(groupOpSelect).val();
+ that.onchange(); // signals that the filter has changed
+ });
+ }
+ // button for adding a new subgroup
+ var inputAddSubgroup = "" + itemText + " ";
+ so++;
+ }
+ }
+ $(".selectopts", trpar).empty().append(s);
+ $(".selectopts", trpar)[0].selectedIndex = 0;
+ if (jgrid.msie && jgrid.msiever() < 9) {
+ var sw = parseInt($("select.selectopts", trpar)[0].offsetWidth, 10) + 1;
+ $(".selectopts", trpar).width(sw);
+ $(".selectopts", trpar).css("width", "auto");
+ }
+ // data
+ $(".data", trpar).empty().append(elm);
+ if (cm.createColumnIndex && searchoptions.generateDatalist) {
+ var dataListId = "dl_" + elm.id,
+ $datalist = $($t).jqGrid("generateDatalistFromColumnIndex", cm.name);
+ if ($datalist != null && $datalist.length > 0) {
+ $(elm).attr("list", dataListId);
+ $(".data", trpar).append($datalist.attr("id", dataListId));
+ }
+ }
+ jgrid.bindEv.call($t, elm, searchoptions);
+ $(".input-elm", trpar).on("change", searchoptions, function (e) {
+ var elem = e.target, column = e.data.column;
+ rule.data = column && column.inputtype === "custom" && isFunction(column.searchoptions.custom_value) ?
+ column.searchoptions.custom_value.call($t, $(this).find(".customelement").first(), "get") :
+ elem.value;
+ if ($(elem).is("input[type=checkbox]") && !$(elem).is(":checked")) {
+ // value of checkbox contains checked value
+ rule.data = $(elem).data("offval");
+ }
+ that.onchange(); // signals that the filter has changed
+ });
+ setTimeout(function () { //IE, Opera, Chrome
+ rule.data = $(elm).val();
+ that.onchange(); // signals that the filter has changed
+ }, 0);
+ });
+
+ // populate drop down with user provided column definitions
+ var j = 0, searchable, hidden, ignoreHiding;
+ for (i = 0; i < that.p.columns.length; i++) {
+ // but show only serchable and serchhidden = true fields
+ searchable = (that.p.columns[i].search === undefined) ? true : that.p.columns[i].search;
+ hidden = (that.p.columns[i].hidden === true);
+ ignoreHiding = (that.p.columns[i].searchoptions.searchhidden === true);
+ if ((ignoreHiding && searchable) || (searchable && !hidden)) {
+ selected = "";
+ if (rule.field === that.p.columns[i].name) {
+ selected = " selected='selected'";
+ j = i;
+ }
+ str += "" + that.p.columns[i].label + " ";
+ }
+ }
+ ruleFieldSelect.append(str);
+
+
+ // create operator container
+ var ruleOperatorTd = $("" +
+ (odataItem !== undefined ? odataItem.text : that.p.cops[itemOper].text) +
+ " ";
+ }
+ }
+ ruleOperatorSelect.append(str);
+ // create data container
+ var ruleDataTd = $("";
+ tmpl += "Default ";
+ each(o.tmplNames, function (i, n) {
+ tmpl += "" + n + " ";
+ });
+ tmpl += " ";
+ }
+
+ bt = "";
+ fid = jqID(fid);
+ o.gbox = gboxSelector; //"#gbox_" + fid;
+ o.height = "auto";
+ fid = "#" + fid;
+ $(fid).jqFilter({
+ columns: columns,
+ filter: o.loadDefaults ? defaultFilters : null,
+ showQuery: o.showQuery,
+ errorcheck: o.errorcheck,
+ sopt: o.sopt,
+ groupButton: o.multipleGroup,
+ ruleButtons: o.multipleSearch,
+ afterRedraw: o.afterRedraw,
+ ops: o.odata,
+ cops: p.customSortOperations,
+ operands: o.operands,
+ ajaxSelectOptions: p.ajaxSelectOptions,
+ groupOps: o.groupOps,
+ onChange: function (filterOptions, filterDiv) {
+ if (filterOptions.showQuery) {
+ $(".query", filterDiv).text(filterDiv.toUserFriendlyString());
+ }
+ fullBoolFeedback.call($t, o.afterChange, "jqGridFilterAfterChange", $(fid), o, filterOptions, filterDiv);
+ },
+ direction: p.direction,
+ id: p.id
+ });
+ fil.append(bt);
+ if (found && o.tmplFilters && o.tmplFilters.length) {
+ $(".ui-template", fil).on("change", function () {
+ var curtempl = $(this).val();
+ if (curtempl === "default") {
+ $(fid).jqFilter("addFilter", defaultFilters);
+ } else {
+ $(fid).jqFilter("addFilter", o.tmplFilters[parseInt(curtempl, 10)]);
+ }
+ return false;
+ });
+ }
+ if (o.multipleGroup === true) { o.multipleSearch = true; }
+ searchFeedback("onInitialize", $(fid));
+ if (o.layer) {
+ jgrid.createModal.call($t, ids, fil, o, gviewSelector, $(gboxSelector)[0], "#" + jqID(o.layer), { position: "relative" });
+ } else {
+ jgrid.createModal.call($t, ids, fil, o, gviewSelector, $(gboxSelector)[0]);
+ }
+ if (o.searchOnEnter || o.closeOnEscape) {
+ $(themodalSelector).keydown(function (e) {
+ var $target = $(e.target);
+ if (o.searchOnEnter && e.which === 13 && // 13 === $.ui.keyCode.ENTER
+ !$target.hasClass("add-group") && !$target.hasClass("add-rule") &&
+ !$target.hasClass("delete-group") && !$target.hasClass("delete-rule") &&
+ (!$target.hasClass("fm-button") || !$target.is("[id$=_query]"))) {
+ $(fid + "_search").click();
+ return false;
+ }
+ if (o.closeOnEscape && e.which === 27) { // 27 === $.ui.keyCode.ESCAPE
+ $("#" + jqID(ids.modalhead)).find(".ui-jqdialog-titlebar-close").click();
+ return false;
+ }
+ });
+ }
+ if (bQ) {
+ $(fid + "_query").on("click", function () {
+ $(".queryresult", fil).toggle();
+ return false;
+ });
+ }
+ if (o.stringResult === undefined) {
+ // to provide backward compatibility, inferring stringResult value from multipleSearch
+ o.stringResult = o.multipleSearch;
+ }
+ $(fid + "_search").on("click", function () {
+ var sdata = {}, res = "", filters, fl = $(fid), $inputs = fl.find(".input-elm");
+ if ($inputs.filter(":focus")) {
+ $inputs = $inputs.filter(":focus");
+ }
+ $inputs.change();
+ filters = fl.jqFilter("filterData");
+ if (o.errorcheck) {
+ fl[0].hideError();
+ if (!o.showQuery) { fl.jqFilter("toSQLString"); }
+ if (fl[0].p.error) {
+ fl[0].showError();
+ return false;
+ }
+ }
+
+ if (o.stringResult || p.datatype === "local") {
+ try {
+ res = JSON.stringify(filters);
+ } catch (ignore) { }
+ if (typeof res === "string") {
+ sdata[o.sFilter] = res;
+ each([o.sField, o.sValue, o.sOper], function () { sdata[this] = ""; });
+ }
+ } else {
+ if (o.multipleSearch) {
+ sdata[o.sFilter] = filters;
+ each([o.sField, o.sValue, o.sOper], function () { sdata[this] = ""; });
+ } else {
+ sdata[o.sField] = filters.rules[0].field;
+ sdata[o.sValue] = filters.rules[0].data;
+ sdata[o.sOper] = filters.rules[0].op;
+ sdata[o.sFilter] = "";
+ }
+ }
+ $.extend(p.postData, sdata);
+ if (fullBoolFeedback.call($t, o.onSearch, "jqGridFilterSearch", p.filters)) {
+ p.search = true;
+ $self.trigger("reloadGrid", [$.extend({ page: 1 }, o.reloadGridSearchOptions || {})]);
+ }
+ if (o.closeAfterSearch) {
+ hideModel();
+ }
+ return false;
+ });
+ $(fid + "_reset").on("click", function () {
+ var sdata = {}, fl1 = $(fid);
+ p.search = false;
+ p.resetsearch = true;
+ if (o.multipleSearch === false) {
+ sdata[o.sField] = sdata[o.sValue] = sdata[o.sOper] = "";
+ } else {
+ sdata[o.sFilter] = "";
+ }
+ fl1[0].resetFilter();
+ if (found) {
+ $(".ui-template", fil).val("default");
+ }
+ $.extend(p.postData, sdata);
+ if (fullBoolFeedback.call($t, o.onReset, "jqGridFilterReset")) {
+ $self.trigger("reloadGrid", [$.extend({ page: 1 }, o.reloadGridResetOptions || {})]);
+ }
+ if (o.closeAfterReset) {
+ hideModel();
+ }
+ return false;
+ });
+ showFilter($(fid));
+ var hoverClasses = getGuiStateStyles.call($t, "hover");
+ // !!! The next row will not work if "states.disabled" is defined using more as one CSS class
+ $(".fm-button:not(." + getGuiStateStyles.call($t, "disabled").split(" ").join(".") + ")", fil).hover(
+ function () { $(this).addClass(hoverClasses); },
+ function () { $(this).removeClass(hoverClasses); }
+ );
+ }
+ });
+ },
+ editGridRow: function (rowid, oMuligrid) { // if one uses jQuery wrapper with multiple grids, then oMultiple specify the object with common options
+ return this.each(function () {
+ var $t = this, $self = $($t), p = $t.p;
+ if (!$t.grid || p == null || !rowid) { return; }
+ // make new copy of the options oMuligrid and use it for ONE specific grid.
+ // p.formEditing can contains grid specific options
+ // we will don't modify the input options oMuligrid
+ var gridId = p.id, getGridRes = base.getGridRes, setSelection = base.setSelection,
+ o = $.extend(true,
+ {
+ top: 0,
+ left: 0,
+ width: 300,
+ datawidth: "auto",
+ height: "auto",
+ dataheight: "auto",
+ //modal: false,
+ //toTop : false,
+ //overlay : 30,
+ drag: true,
+ resize: true,
+ url: null,
+ mtype: "POST",
+ clearAfterAdd: true,
+ closeAfterEdit: false,
+ reloadAfterSubmit: true,
+ onInitializeForm: null,
+ beforeInitData: null,
+ beforeShowForm: null,
+ afterShowForm: null,
+ beforeSubmit: null,
+ afterSubmit: null,
+ onclickSubmit: null,
+ afterComplete: null,
+ onclickPgButtons: null,
+ afterclickPgButtons: null,
+ editData: {},
+ //jqModal : true,
+ closeOnEscape: false,
+ addedrow: "first",
+ topinfo: "",
+ bottominfo: "",
+ savekey: [false, 13],
+ navkeys: [false, 38, 40],
+ checkOnSubmit: false,
+ checkOnUpdate: false,
+ _savedData: {},
+ processing: false,
+ onClose: null,
+ ajaxEditOptions: {},
+ serializeEditData: null,
+ viewPagerButtons: true,
+ overlayClass: getGuiStyles.call(this, "overlay"),
+ removemodal: true,
+ skipPostTypes: ["image", "file"],
+ saveui: "enable",
+ savetext: getGridRes.call($self, "defaults.savetext") || "Saving..."
+ },
+ getGridRes.call($self, "edit"),
+ jgrid.edit,
+ p.formEditing || {},
+ oMuligrid || {});
+
+ var frmgr = "FrmGrid_" + gridId, frmgrId = frmgr, frmtborg = "TblGrid_" + gridId, frmtb = "#" + jqID(frmtborg), frmtb2 = frmtb + "_2",
+ ids = { themodal: "editmod" + gridId, modalhead: "edithd" + gridId, modalcontent: "editcnt" + gridId, resizeAlso: frmgr },
+ themodalSelector = "#" + jqID(ids.themodal), gboxSelector = p.gBox, colModel = p.colModel, iColByName = p.iColByName,
+ maxCols = 1, maxRows = 0, postdata, diff, editOrAdd, commonIconClass = o.commonIconClass,
+ hideModal = function () {
+ jgrid.hideModal(themodalSelector, {
+ gb: gboxSelector,
+ jqm: o.jqModal,
+ onClose: o.onClose,
+ removemodal: o.removemodal
+ });
+ },
+ errcap = getGridRes.call($self, "errors.errcap"),
+ editFeedback = function () {
+ var args = $.makeArray(arguments);
+ args.unshift("");
+ args.unshift("AddEdit");
+ args.unshift(o);
+ return jgridFeedback.apply($t, args);
+ },
+ hoverClasses = getGuiStateStyles.call($t, "hover"),
+ disabledClass = getGuiStateStyles.call($t, "disabled"),
+ highlightClass = getGuiStateStyles.call($t, "select"),
+ activeClass = getGuiStateStyles.call($t, "active"),
+ errorClass = getGuiStateStyles.call($t, "error");
+
+ $(themodalSelector).remove();
+ frmgr = "#" + jqID(frmgr);
+ if (rowid === "new") {
+ rowid = "_empty";
+ editOrAdd = "add";
+ o.caption = o.addCaption;
+ } else {
+ o.caption = o.editCaption;
+ editOrAdd = "edit";
+ }
+ var closeovrl = true;
+ if (o.checkOnUpdate && (o.jqModal === true || o.jqModal === undefined) && !o.modal) {
+ closeovrl = false;
+ }
+ function getFormData() {
+ $(frmtb + " > tbody > tr > td .FormElement").each(function () {
+ var $celm = $(".customelement", this), nm = this.name, cm, iCol, editoptions, formatoptions, newformat, type;
+ if ($celm.length) {
+ nm = $celm.attr("name");
+ iCol = iColByName[nm];
+ if (iCol !== undefined) {
+ cm = colModel[iCol];
+ editoptions = cm.editoptions || {};
+ if ($.isFunction(editoptions.custom_value)) {
+ try {
+ postdata[nm] = editoptions.custom_value.call($t, $("#" + jqID(nm), frmtb), "get");
+ if (postdata[nm] === undefined) { throw "e1"; }
+ } catch (e) {
+ if (e === "e1") {
+ jgrid.info_dialog.call($t, errcap, "function 'custom_value' " + o.msg.novalue, o.bClose);
+ } else {
+ jgrid.info_dialog.call($t, errcap, e.message, o.bClose);
+ }
+ }
+ return true;
+ }
+ }
+ } else {
+ type = $(this)[0].type;
+ switch (type) {
+ case "checkbox":
+ postdata[nm] = $(this).is(":checked") ? $(this).val() : $(this).data("offval");
+ break;
+ case "select-one":
+ postdata[nm] = $("option:selected", this).val();
+ break;
+ case "select-multiple":
+ postdata[nm] = $(this).val();
+ postdata[nm] = postdata[nm] ? postdata[nm].join(",") : "";
+ var selectedText = [];
+ $("option:selected", this).each(
+ function (i, selected) {
+ selectedText[i] = $(selected).text();
+ }
+ );
+ break;
+ case "date":
+ postdata[nm] = $(this).val();
+ if (String(postdata[nm]).split("-").length === 3) {
+ iCol = iColByName[nm];
+ if (iCol !== undefined) {
+ cm = colModel[iCol];
+ formatoptions = cm.formatoptions || {};
+ newformat = formatoptions.newformat || getGridRes.call($self, "formatter.date.newformat");
+ postdata[nm] = jgrid.parseDate.call($self[0], "Y-m-d", postdata[nm], newformat);
+ }
+ }
+ break;
+ default:
+ if (type !== undefined && $.inArray(type, o.skipPostTypes) < 0) {
+ postdata[nm] = $(this).val();
+ }
+ break;
+ }
+ }
+ });
+ return true;
+ }
+ function createData(rowid1, tb, maxcols) {
+ var cnt = 0, retpos = [], ind = false, $tb = $(tb),
+ tdtmpl = " ", tmpl = "", i; //*2
+ for (i = 1; i <= maxcols; i++) {
+ tmpl += tdtmpl;
+ }
+ if (rowid1 !== "_empty") {
+ ind = base.getInd.call($self, rowid1);
+ }
+ $(colModel).each(function (iCol) {
+ var cm = this, nm = cm.name, $td, hc, trdata, tmp, elc, editable = cm.editable, disabled = false, readonly = false,
+ mode = rowid1 === "_empty" ? "addForm" : "editForm";
+ if ($.isFunction(editable)) {
+ editable = editable.call($t, {
+ rowid: rowid1,
+ iCol: iCol,
+ iRow: ind, // can be false for Add operation
+ cmName: nm,
+ cm: cm,
+ mode: mode
+ });
+ }
+ // hidden fields are included in the form
+ if (cm.editrules && cm.editrules.edithidden === true) {
+ hc = false;
+ } else {
+ hc = cm.hidden === true || editable === "hidden" ? true : false;
+ }
+ switch (String(editable).toLowerCase()) {
+ case "hidden":
+ editable = true;
+ break;
+ case "disabled":
+ editable = true;
+ disabled = true;
+ break;
+ case "readonly":
+ editable = true;
+ readonly = true;
+ break;
+ }
+ if (nm !== "cb" && nm !== "subgrid" && editable === true && nm !== "rn") {
+ if (ind === false) {
+ tmp = "";
+ } else {
+ $td = $($t.rows[ind].cells[iCol]); // $("td[role=gridcell]:eq(" + i + ")", $t.rows[ind])
+ try {
+ tmp = $.unformat.call($t, $td, { rowId: rowid1, colModel: cm }, iCol);
+ } catch (_) {
+ tmp = (cm.edittype && cm.edittype === "textarea") ? $td.text() : $td.html();
+ }
+ if (isEmptyString(tmp)) { tmp = ""; }
+ }
+ var opt = $.extend({}, cm.editoptions || {},
+ { id: nm, name: nm, rowId: rowid1, mode: mode, cm: cm, iCol: iCol }),
+ frmopt = $.extend({}, { elmprefix: "", elmsuffix: "", rowabove: false, rowcontent: "" }, cm.formoptions || {}),
+ rp = parseInt(frmopt.rowpos, 10) || cnt + 1,
+ cp = parseInt((parseInt(frmopt.colpos, 10) || 1) * 2, 10);
+ if (rowid1 === "_empty" && opt.defaultValue) {
+ tmp = $.isFunction(opt.defaultValue) ? opt.defaultValue.call($t) : opt.defaultValue;
+ }
+ if (!cm.edittype) { cm.edittype = "text"; }
+ if (p.autoEncodeOnEdit) { tmp = jgrid.oldDecodePostedData(tmp); }
+ elc = jgrid.createEl.call($t, cm.edittype, opt, tmp, false, $.extend({}, jgrid.ajaxOptions, p.ajaxSelectOptions || {}));
+ //if(tmp === "" && cm.edittype == "checkbox") {tmp = $(elc).data("offval");}
+ //if(tmp === "" && cm.edittype == "select") {tmp = $("option:eq(0)",elc).text();}
+ if (o.checkOnSubmit || o.checkOnUpdate) { o._savedData[nm] = tmp; }
+ $(elc).addClass("FormElement");
+ if ($.inArray(cm.edittype, ["text", "textarea", "checkbox", "password", "select"]) > -1) {
+ $(elc).addClass(getGuiStyles.call($t, "dialog.dataField"));
+ }
+ trdata = $tb.find("tr[data-rowpos=" + rp + "]");
+ if (frmopt.rowabove) {
+ var newdata = $("" + frmopt.rowcontent + " " + (o.topinfo || " ") + "
").append($("
").append(frm)).append(bt);
+ jgrid.createModal.call($t, ids, tms, o, p.gView, $(gboxSelector)[0]);
+ // TODO: remove the call of jgrid.bindEv and probably call of opt.custom_value from createData
+ // and place the calls here AFTER the form are placed on the HTML page
+ if (o.topinfo) { $(".tinfo", frmtb).show(); }
+ if (o.bottominfo) { $(".binfo", frmtb2).show(); }
+ tms = null;
+ bt = null;
+ $(themodalSelector).keydown(function (e) {
+ var wTagName = (e.target.tagName || "").toUpperCase(), $focused, idFocused;
+ if ($(frmgr).data("disabled") === true) { return false; }//??
+ if (e.which === 13) {
+ if (wTagName !== "TEXTAREA") {
+ $focused = $(frmtb2).find(":focus");
+ idFocused = $focused.attr("id");
+ if ($focused.length > 0 && $.inArray(idFocused, ["pData", "nData", "cData"]) >= 0) {
+ $focused.trigger("click");
+ return false;
+ }
+ if (o.savekey[0] === true && o.savekey[1] === 13) {
+ $("#sData", frmtb2).trigger("click");
+ return false;
+ }
+ }
+ }
+ if (o.savekey[0] === true && e.which === o.savekey[1]) { // save
+ if (wTagName !== "TEXTAREA") {
+ $("#sData", frmtb2).trigger("click");
+ return false;
+ }
+ }
+ if (e.which === 27) {
+ if (!checkUpdates()) { return false; }
+ if (cle) {
+ hideModal();
+ }
+ return false;
+ }
+ if (o.navkeys[0] === true) {
+ if ($("#id_g", frmtb).val() === "_empty") { return true; }
+ if (e.which === o.navkeys[1]) { //up
+ $("#pData", frmtb2).trigger("click");
+ return false;
+ }
+ if (e.which === o.navkeys[2]) { //down
+ $("#nData", frmtb2).trigger("click");
+ return false;
+ }
+ }
+ });
+ if (o.checkOnUpdate) {
+ $("a.ui-jqdialog-titlebar-close span", themodalSelector).removeClass("jqmClose");
+ $("a.ui-jqdialog-titlebar-close", themodalSelector).off("click")
+ .click(function () {
+ if (!checkUpdates()) {
+ return false;
+ }
+ hideModal();
+ return false;
+ });
+ }
+ addFormIcon($("#sData", frmtb2), o.saveicon, commonIconClass);
+ addFormIcon($("#cData", frmtb2), o.closeicon, commonIconClass);
+ if (o.checkOnSubmit || o.checkOnUpdate) {
+ bS = builderFmButon.call($t, "sNew", o.bYes);
+ bN = builderFmButon.call($t, "nNew", o.bNo);
+ bC = builderFmButon.call($t, "cNew", o.bExit);
+ var zI = o.zIndex || 999;
+ zI++;
+ $("
" + o.saveData + "
").insertAfter(frmgr);
+ $("#sNew", themodalSelector).click(function () {
+ // if the form will be hidden at the first usage and it will be shown at the next usage
+ // then the execution context click handler and all other functions like postIt()
+ // will contains the variables (like rowid, postdata and so on) from THE FIRST call
+ // of editGridRow. One should be very careful in the code of postIt()
+ postIt();
+ $(frmgr).data("disabled", false);
+ $(".confirm", themodalSelector).hide();
+ return false;
+ });
+ $("#nNew", themodalSelector).click(function () {
+ $(".confirm", themodalSelector).hide();
+ $(frmgr).data("disabled", false);
+ setTimeout(function () {
+ $(frmgr).find("input,textarea,select,button,object,*[tabindex]")
+ .filter(":input:visible:not(:disabled)")
+ .first()
+ .focus();
+ }, 0);
+ return false;
+ });
+ $("#cNew", themodalSelector).click(function () {
+ // if the form will be hidden at the first usage and it will be shown at the next usage
+ // then the execution context click handler and all other functions like postIt()
+ // will contains the variables (like o) from THE FIRST call
+ $(".confirm", themodalSelector).hide();
+ $(frmgr).data("disabled", false);
+ hideModal();
+ return false;
+ });
+ }
+ // here initform - only once
+ editFeedback("onInitializeForm", $(frmgr), editOrAdd);
+ if (rowid === "_empty" || !o.viewPagerButtons) {
+ $("#pData,#nData", frmtb2).hide();
+ } else {
+ $("#pData,#nData", frmtb2).show();
+ }
+ editFeedback("beforeShowForm", $(frmgr), editOrAdd);
+ $(themodalSelector).data("onClose", o.onClose);
+ jgrid.viewModal.call($t, themodalSelector, {
+ gbox: gboxSelector,
+ jqm: o.jqModal,
+ overlay: o.overlay,
+ modal: o.modal,
+ overlayClass: o.overlayClass,
+ toTop: o.toTop,
+ onHide: function (h) {
+ h.w.remove();
+ if (h.o) { h.o.remove(); }
+ }
+ });
+ if (!closeovrl) {
+ $("." + jqID(o.overlayClass)).click(function () {
+ if (!checkUpdates()) { return false; }
+ hideModal();
+ return false;
+ });
+ }
+ $(".fm-button", themodalSelector).hover(
+ function () { $(this).addClass(hoverClasses); },
+ function () { $(this).removeClass(hoverClasses); }
+ );
+ $("#sData", frmtb2).click(function () {
+ postdata = {};
+ $("#FormError", frmtb).hide();
+ // all depend on ret array
+ //ret[0] - succes
+ //ret[1] - msg if not succes
+ //ret[2] - the id that will be set if reload after submit false
+ getFormData();
+ if (postdata[gridId + "_id"] === "_empty") {
+ postIt();
+ } else if (o.checkOnSubmit === true) {
+ diff = compareData(postdata, o._savedData);
+ if (diff) {
+ $(frmgr).data("disabled", true);
+ $(".confirm", themodalSelector).show();
+ } else {
+ postIt();
+ }
+ } else {
+ postIt();
+ }
+ return false;
+ });
+ $("#cData", frmtb2).click(function () {
+ if (!checkUpdates()) { return false; }
+ hideModal();
+ return false;
+ });
+ $("#nData", frmtb2).click(function () {
+ if (!checkUpdates()) { return false; }
+ $("#FormError", frmtb).hide();
+ var npos = getCurrPos();
+ npos[0] = parseInt(npos[0], 10);
+ if (npos[0] !== -1 && npos[1][npos[0] + 1]) {
+ if (!editFeedback("onclickPgButtons", "next", $(frmgr), npos[1][npos[0]])) { return false; }
+ fillData(npos[1][npos[0] + 1], frmgr);
+ setSelection.call($self, npos[1][npos[0] + 1]);
+ editFeedback("afterclickPgButtons", "next", $(frmgr), npos[1][npos[0] + 1]);
+ updateNav(npos[0] + 1, npos);
+ }
+ return false;
+ });
+ $("#pData", frmtb2).click(function () {
+ if (!checkUpdates()) { return false; }
+ $("#FormError", frmtb).hide();
+ var ppos = getCurrPos();
+ if (ppos[0] !== -1 && ppos[1][ppos[0] - 1]) {
+ if (!editFeedback("onclickPgButtons", "prev", $(frmgr), ppos[1][ppos[0]])) { return false; }
+ if (hasOneFromClasses($("#" + jqID(ppos[1][ppos[0] - 1])), disabledClass)) { return false; }
+ fillData(ppos[1][ppos[0] - 1], frmgr);
+ setSelection.call($self, ppos[1][ppos[0] - 1]);
+ editFeedback("afterclickPgButtons", "prev", $(frmgr), ppos[1][ppos[0] - 1]);
+ updateNav(ppos[0] - 1, ppos);
+ }
+ return false;
+ });
+ editFeedback("afterShowForm", $(frmgr), editOrAdd);
+ var posInit = getCurrPos();
+ updateNav(posInit[0], posInit);
+ });
+ },
+ viewGridRow: function (rowid, oMuligrid) {
+ return this.each(function () {
+ var $t = this, $self = $($t), p = $t.p;
+ if (!$t.grid || p == null || !rowid) { return; }
+ // make new copy of the options oMuligrid and use it for ONE specific grid.
+ // p.formViewing can contains grid specific options
+ // we will don't modify the input options oMuligrid
+ var gridId = p.id,
+ o = $.extend(true,
+ {
+ top: 0,
+ left: 0,
+ width: 0,
+ datawidth: "auto",
+ height: "auto",
+ dataheight: "auto",
+ //modal: false,
+ //toTop : false,
+ //overlay: 30,
+ drag: true,
+ resize: true,
+ //jqModal: true,
+ closeOnEscape: false,
+ labelswidth: "", //"30%",
+ navkeys: [false, 38, 40],
+ onClose: null,
+ beforeShowForm: null,
+ beforeInitData: null,
+ viewPagerButtons: true,
+ removemodal: true
+ },
+ base.getGridRes.call($self, "view"),
+ jgrid.view || {},
+ p.formViewing || {},
+ oMuligrid || {});
+
+ var frmgr = "#ViewGrid_" + jqID(gridId), frmtb = "#ViewTbl_" + jqID(gridId), frmtb2 = frmtb + "_2",
+ frmgrId = "ViewGrid_" + gridId, frmtbId = "ViewTbl_" + gridId, commonIconClass = o.commonIconClass,
+ ids = { themodal: "viewmod" + gridId, modalhead: "viewhd" + gridId, modalcontent: "viewcnt" + gridId, resizeAlso: frmgrId },
+ themodalSelector = "#" + jqID(ids.themodal), gboxSelector = p.gBox, colModel = p.colModel,
+ maxCols = 1, maxRows = 0,
+ viewFeedback = function () {
+ var args = $.makeArray(arguments);
+ args.unshift("");
+ args.unshift("View");
+ args.unshift(o);
+ return jgridFeedback.apply($t, args);
+ },
+ hideModal = function () {
+ jgrid.hideModal(themodalSelector, {
+ gb: gboxSelector,
+ jqm: o.jqModal,
+ onClose: o.onClose,
+ removemodal: o.removemodal
+ });
+ },
+ hoverClasses = getGuiStateStyles.call($t, "hover"),
+ disabledClass = getGuiStateStyles.call($t, "disabled");
+
+ function focusaref() { //Sfari 3 issues
+ if (o.closeOnEscape === true || o.navkeys[0] === true) {
+ setTimeout(function () { $("#cData").focus(); }, 0);
+ }
+ }
+ function createData(rowid1, tb, maxcols) {
+ var nm, hc, $trdata, cnt = 0, tmp, retpos = [], ind = base.getInd.call($self, rowid1), i,
+ viewDataClasses = getGuiStyles.call($t, "dialog.viewData"), $tb = $(tb),
+ viewLabelClasses = getGuiStyles.call($t, "dialog.viewLabel"),
+ labelsWidth = String(o.labelswidth) + (!o.labelswidth || isNaN(o.labelswidth) ? "" : "px"),
+ tdtmpl = " ",
+ tmpl = "", fmtnum = ["integer", "number", "currency"], max1 = 0, max2 = 0, maxw, setme, viewfld;
+ for (i = 0; i < maxcols; i++) {
+ tmpl += tdtmpl;
+ }
+ // find max number align right with property formatter
+ $(colModel).each(function () {
+ var cm = this;
+ if (cm.editrules && cm.editrules.edithidden === true) {
+ hc = false;
+ } else {
+ hc = cm.hidden === true ? true : false;
+ }
+ if (!hc && cm.align === "right") {
+ if (cm.formatter && $.inArray(cm.formatter, fmtnum) !== -1) {
+ max1 = Math.max(max1, parseInt(cm.width, 10));
+ } else {
+ max2 = Math.max(max2, parseInt(cm.width, 10));
+ }
+ }
+ });
+ maxw = max1 !== 0 ? max1 : max2 !== 0 ? max2 : 0;
+ $(colModel).each(function (iCol) {
+ var cm = this;
+ nm = cm.name;
+ setme = false;
+ // hidden fields are included in the form
+ if (cm.editrules && cm.editrules.edithidden === true) {
+ hc = false;
+ } else {
+ hc = cm.hidden === true ? true : false;
+ }
+ viewfld = (typeof cm.viewable !== "boolean") ? true : cm.viewable;
+ if (nm !== "cb" && nm !== "subgrid" && nm !== "rn" && viewfld) {
+ tmp = ind === false ? "" : jgrid.getDataFieldOfCell.call($t, $t.rows[ind], iCol).html();
+ setme = cm.align === "right" && maxw !== 0 ? true : false;
+ var frmopt = $.extend({}, { rowabove: false, rowcontent: "" }, cm.formoptions || {}),
+ rp = parseInt(frmopt.rowpos, 10) || cnt + 1,
+ cp = parseInt((parseInt(frmopt.colpos, 10) || 1) * 2, 10);
+ if (frmopt.rowabove) {
+ var newdata = $("" + frmopt.rowcontent + " " : ">") +
+ (labelText || " ") + " ");
+ $data[isEmptyString($data.html()) ? "html" : "append"]("" : ">") +
+ (tmp || " ") + " ").attr("id", "v_" + nm);
+ if (setme) {
+ $("td:eq(" + (cp - 1) + ") span", $trdata[0]).css({ "text-align": "right", width: maxw + "px" });
+ }
+ if (hc) {
+ $label.add($data).css("visibility", "hidden");
+ }
+ retpos[cnt] = iCol;
+ cnt++;
+ }
+ });
+ hideRowsWithoutVissibleCells($tb);
+ if (cnt > 0) {
+ var idrow = $("
"),
+ frm = frmDiv.children("form.FormGrid"),
+ tbl = $("");
+
+ $(themodalSelector).remove();
+ $(colModel).each(function () {
+ var fmto = this.formoptions;
+ maxCols = Math.max(maxCols, fmto ? fmto.colpos || 0 : 0);
+ maxRows = Math.max(maxRows, fmto ? fmto.rowpos || 0 : 0);
+ });
+ // set the id.
+ frm.append(tbl);
+ if (!viewFeedback("beforeInitData", frm)) { return; }
+ createData(rowid, tbl, maxCols);
+ var rtlb = p.direction === "rtl" ? true : false,
+ bp = rtlb ? "nData" : "pData",
+ bn = rtlb ? "pData" : "nData",
+ // buttons at footer
+ bP = builderFmButon.call($t, bp, "", mergeCssClasses(commonIconClass, o.prevIcon), "", "left"),
+ bN = builderFmButon.call($t, bn, "", mergeCssClasses(commonIconClass, o.nextIcon), "", "right"),
+ bC = builderFmButon.call($t, "cData", o.bClose);
+
+ if (maxRows > 0) {
+ var sd = [];
+ $.each($(tbl)[0].rows, function (i, r) {
+ sd[i] = r;
+ });
+ sd.sort(function (a, b) {
+ if (a.rp > b.rp) { return 1; }
+ if (a.rp < b.rp) { return -1; }
+ return 0;
+ });
+ $.each(sd, function (index, row) {
+ $("tbody", tbl).append(row);
+ });
+ }
+ o.gbox = gboxSelector;
+ var bt = $("
").append(frmDiv).append("");
+ jgrid.createModal.call($t, ids, bt, o, p.gView, $(p.gView)[0]);
+ if (!o.viewPagerButtons) { $("#pData, #nData", frmtb2).hide(); }
+ bt = null;
+ $(themodalSelector).keydown(function (e) {
+ var $focused, idFocused;
+ if ($(frmgr).data("disabled") === true) { return false; }//??
+ if (e.which === 13) {
+ $focused = $(frmtb2).find(":focus");
+ idFocused = $focused.attr("id");
+ if ($focused.length > 0 && $.inArray(idFocused, ["pData", "nData", "cData"]) >= 0) {
+ $focused.trigger("click");
+ return false;
+ }
+ }
+
+ if (e.which === 27) {
+ if (o.closeOnEscape) {
+ hideModal();
+ }
+ return false;
+ }
+ if (o.navkeys[0] === true) {
+ if (e.which === o.navkeys[1]) { //up
+ $("#pData", frmtb2).trigger("click");
+ return false;
+ }
+ if (e.which === o.navkeys[2]) { //down
+ $("#nData", frmtb2).trigger("click");
+ return false;
+ }
+ }
+ });
+ addFormIcon($("#cData", frmtb2), o.closeicon, commonIconClass);
+ viewFeedback("beforeShowForm", $(frmgr));
+ jgrid.viewModal.call($t, themodalSelector, {
+ gbox: gboxSelector,
+ jqm: o.jqModal,
+ overlay: o.overlay,
+ toTop: o.toTop,
+ modal: o.modal,
+ onHide: function (h) {
+ h.w.remove();
+ if (h.o) { h.o.remove(); }
+ }
+ });
+ $(".fm-button:not(." + disabledClass.split(" ").join(".") + ")", frmtb2).hover(
+ function () { $(this).addClass(hoverClasses); },
+ function () { $(this).removeClass(hoverClasses); }
+ );
+ focusaref();
+ $("#cData", frmtb2).click(function () {
+ hideModal();
+ return false;
+ });
+ $("#nData", frmtb2).click(function () {
+ $("#FormError", frmtb).hide();
+ var npos = getCurrPos();
+ npos[0] = parseInt(npos[0], 10);
+ if (npos[0] !== -1 && npos[1][npos[0] + 1]) {
+ if (!viewFeedback("onclickPgButtons", "next", $(frmgr), npos[1][npos[0]])) { return false; }
+ fillData(npos[1][npos[0] + 1]);
+ base.setSelection.call($self, npos[1][npos[0] + 1]);
+ viewFeedback("afterclickPgButtons", "next", $(frmgr), npos[1][npos[0] + 1]);
+ updateNav(npos[0] + 1, npos);
+ }
+ focusaref();
+ return false;
+ });
+ $("#pData", frmtb2).click(function () {
+ $("#FormError", frmtb).hide();
+ var ppos = getCurrPos();
+ if (ppos[0] !== -1 && ppos[1][ppos[0] - 1]) {
+ if (!viewFeedback("onclickPgButtons", "prev", $(frmgr), ppos[1][ppos[0]])) { return false; }
+ fillData(ppos[1][ppos[0] - 1]);
+ base.setSelection.call($self, ppos[1][ppos[0] - 1]);
+ viewFeedback("afterclickPgButtons", "prev", $(frmgr), ppos[1][ppos[0] - 1]);
+ updateNav(ppos[0] - 1, ppos);
+ }
+ focusaref();
+ return false;
+ });
+ var posInit = getCurrPos();
+ updateNav(posInit[0], posInit);
+ });
+ },
+ delGridRow: function (rowids, oMuligrid) {
+ return this.each(function () {
+ var $t = this, p = $t.p, $self = $($t);
+ if (!$t.grid || p == null || !rowids) { return; }
+ // make new copy of the options oMuligrid and use it for ONE specific grid.
+ // p.formDeleting can contains grid specific options
+ // we will don't modify the input options oMuligrid
+ var gridId = p.id,
+ o = $.extend(true,
+ {
+ top: 0,
+ left: 0,
+ width: 240,
+ removemodal: true,
+ height: "auto",
+ dataheight: "auto",
+ datawidth: "auto",
+ //modal: false,
+ //toTop: false,
+ //overlay: 30,
+ drag: true,
+ resize: true,
+ url: "",
+ mtype: "POST",
+ reloadAfterSubmit: true,
+ beforeShowForm: null,
+ beforeInitData: null,
+ afterShowForm: null,
+ beforeSubmit: null,
+ onclickSubmit: null,
+ afterSubmit: null,
+ //jqModal : true,
+ closeOnEscape: false,
+ delData: {},
+ onClose: null,
+ ajaxDelOptions: {},
+ processing: false,
+ serializeDelData: null,
+ useDataProxy: false,
+ delui: "disable", // "enable", "enable" or "block"
+ deltext: getGridRes.call($self, "defaults.deltext") || "Deleting..."
+ },
+ base.getGridRes.call($self, "del"),
+ jgrid.del || {},
+ p.formDeleting || {},
+ oMuligrid || {});
+
+ var dtblId = "DelTbl_" + gridId, dtbl = "#DelTbl_" + jqID(gridId), postd, idname, opers, oper,
+ ids = { themodal: "delmod" + gridId, modalhead: "delhd" + gridId, modalcontent: "delcnt" + gridId, resizeAlso: dtblId },
+ themodalSelector = "#" + jqID(ids.themodal), gboxSelector = p.gBox, commonIconClass = o.commonIconClass,
+ deleteFeedback = function () {
+ var args = $.makeArray(arguments);
+ args.unshift("");
+ args.unshift("Delete");
+ args.unshift(o);
+ return jgridFeedback.apply($t, args);
+ },
+ hoverClasses = getGuiStateStyles.call($t, "hover"),
+ activeClass = getGuiStateStyles.call($t, "active"),
+ errorClass = getGuiStateStyles.call($t, "error");
+
+ if (!$.isArray(rowids)) { rowids = [String(rowids)]; }
+ if ($(themodalSelector)[0] !== undefined) {
+ if (!deleteFeedback("beforeInitData", $(dtbl))) { return; }
+ $("#DelData>td", dtbl).text(rowids.join()).data("rowids", rowids);
+ $("#DelError", dtbl).hide();
+ if (o.processing === true) {
+ o.processing = false;
+ $("#dData", dtbl).removeClass(activeClass);
+ }
+ deleteFeedback("beforeShowForm", $(dtbl));
+ jgrid.viewModal.call($t, themodalSelector, {
+ gbox: gboxSelector,
+ jqm: o.jqModal,
+ jqM: false,
+ overlay: o.overlay,
+ toTop: o.toTop,
+ modal: o.modal
+ });
+ deleteFeedback("afterShowForm", $(dtbl));
+ } else {
+ var dh = isNaN(o.dataheight) ? o.dataheight : o.dataheight + "px",
+ dw = isNaN(o.datawidth) ? o.datawidth : o.datawidth + "px",
+ tbl = "";
+ var bS = builderFmButon.call($t, "dData", o.bSubmit),
+ bC = builderFmButon.call($t, "eData", o.bCancel);
+ tbl += "";
+ o.gbox = gboxSelector;
+ jgrid.createModal.call($t, ids, tbl, o, p.gView, $(p.gView)[0]);
+ $("#DelData>td", dtbl).data("rowids", rowids);
+
+ if (!deleteFeedback("beforeInitData", $(tbl))) { return; }
+ $(".fm-button", dtbl + "_2").hover(
+ function () { $(this).addClass(hoverClasses); },
+ function () { $(this).removeClass(hoverClasses); }
+ );
+ addFormIcon($("#dData", dtbl + "_2"), o.delicon, commonIconClass);
+ addFormIcon($("#eData", dtbl + "_2"), o.cancelicon, commonIconClass);
+ $("#dData", dtbl + "_2").click(function () {
+ var ret = [true, ""], pk, $delData = $("#DelData>td", dtbl),
+ postdata = $delData.text(), //the pair is name=val1,val2,...
+ formRowIds = $delData.data("rowids"),
+ cs = {};
+ if ($.isFunction(o.onclickSubmit)) { cs = o.onclickSubmit.call($t, o, postdata) || {}; }
+ if ($.isFunction(o.beforeSubmit)) { ret = o.beforeSubmit.call($t, postdata) || ret; }
+ if (ret[0] && !o.processing) {
+ o.processing = true;
+ opers = p.prmNames;
+ postd = $.extend({}, o.delData, cs);
+ oper = opers.oper;
+ postd[oper] = opers.deloper;
+ idname = opers.id;
+ postdata = formRowIds.slice();
+ if (!postdata.length) { return false; }
+ for (pk in postdata) {
+ if (postdata.hasOwnProperty(pk)) {
+ postdata[pk] = jgrid.stripPref(p.idPrefix, postdata[pk]);
+ }
+ }
+ postd[idname] = postdata.join();
+ $(this).addClass(activeClass);
+ var url = o.url || p.editurl,
+ ajaxOptions = $.extend({
+ url: $.isFunction(url) ? url.call($t, postd[idname], postd, o) : url,
+ type: o.mtype,
+ data: $.isFunction(o.serializeDelData) ? o.serializeDelData.call($t, postd) : postd,
+ complete: function (jqXHR, textStatus) {
+ var i;
+ $self.jqGrid("progressBar", { method: "hide", loadtype: o.delui });
+ $("#dData", dtbl + "_2").removeClass(activeClass);
+ if ((jqXHR.status >= 300 && jqXHR.status !== 304) || (jqXHR.status === 0 && jqXHR.readyState === 4)) {
+ ret[0] = false;
+ if ($.isFunction(o.errorTextFormat)) {
+ ret[1] = o.errorTextFormat.call($t, jqXHR);
+ } else {
+ ret[1] = textStatus + " Status: '" + jqXHR.statusText + "'. Error code: " + jqXHR.status;
+ }
+ } else {
+ // data is posted successful
+ // execute aftersubmit with the returned data from server
+ if ($.isFunction(o.afterSubmit)) {
+ ret = o.afterSubmit.call($t, jqXHR, postd) || [true];
+ }
+ }
+ if (ret[0] === false) {
+ $("#DelError>td", dtbl).html(ret[1]);
+ $("#DelError", dtbl).show();
+ } else {
+ if (p.datatype === "local" || p.treeGrid === true || !o.reloadAfterSubmit) {
+ if (p.treeGrid === true) {
+ try { base.delTreeNode.call($self, formRowIds[0]); } catch (ignore) { }
+ } else {
+ formRowIds = formRowIds.slice(); // make copy for save deleting
+ for (i = 0; i < formRowIds.length; i++) {
+ base.delRowData.call($self, formRowIds[i]);
+ }
+ }
+ }
+ if (o.reloadAfterSubmit) {
+ $self.trigger("reloadGrid", [$.extend({}, o.reloadGridOptions || {})]);
+ }
+ setTimeout(function () {
+ deleteFeedback("afterComplete", jqXHR, postdata, $(dtbl));
+ }, 50);
+ }
+ o.processing = false;
+ if (ret[0]) {
+ jgrid.hideModal(themodalSelector, {
+ gb: gboxSelector,
+ jqm: o.jqModal,
+ onClose: o.onClose,
+ removemodal: o.removemodal
+ });
+ }
+ }
+ }, jgrid.ajaxOptions, o.ajaxDelOptions);
+
+
+ if (!ajaxOptions.url && !o.useDataProxy) {
+ if ($.isFunction(p.dataProxy)) {
+ o.useDataProxy = true;
+ } else {
+ ret[0] = false;
+ ret[1] += " " + jgrid.errors.nourl;
+ }
+ }
+ if (ret[0]) {
+ $self.jqGrid("progressBar", { method: "show", loadtype: o.delui, htmlcontent: o.deltext });
+ if (o.useDataProxy) {
+ var dpret = p.dataProxy.call($t, ajaxOptions, "del_" + gridId);
+ if (dpret === undefined) {
+ dpret = [true, ""];
+ }
+ if (dpret[0] === false) {
+ ret[0] = false;
+ ret[1] = dpret[1] || "Error deleting the selected row!";
+ } else {
+ jgrid.hideModal(themodalSelector, {
+ gb: gboxSelector,
+ jqm: o.jqModal,
+ onClose: o.onClose,
+ removemodal: o.removemodal
+ });
+ }
+ } else {
+ if (ajaxOptions.url === "clientArray") {
+ postd = ajaxOptions.data;
+ ajaxOptions.complete({ status: 200, statusText: "" }, "");
+ } else {
+ $.ajax(ajaxOptions);
+ }
+ }
+ }
+ }
+
+ if (ret[0] === false) {
+ $("#DelError>td", dtbl).html(ret[1]);
+ $("#DelError", dtbl).show();
+ }
+ return false;
+ });
+ $("#eData", dtbl + "_2").click(function () {
+ jgrid.hideModal(themodalSelector, {
+ gb: gboxSelector,
+ jqm: o.jqModal,
+ onClose: o.onClose,
+ removemodal: o.removemodal
+ });
+ return false;
+ });
+ deleteFeedback("beforeShowForm", $(dtbl));
+ jgrid.viewModal.call($t, themodalSelector, {
+ gbox: gboxSelector,
+ jqm: o.jqModal,
+ overlay: o.overlay,
+ toTop: o.toTop,
+ modal: o.modal
+ });
+ deleteFeedback("afterShowForm", $(dtbl));
+ }
+ if (o.closeOnEscape === true) {
+ setTimeout(function () {
+ $(".ui-jqdialog-titlebar-close", "#" + jqID(ids.modalhead))
+ .attr("tabindex", "-1")
+ .focus();
+ }, 0);
+ }
+ });
+ },
+ navGrid: function (elem, oMuligrid, pEdit, pAdd, pDel, pSearch, pView) {
+ if (typeof elem === "object") {
+ // the option pager are skipped
+ pView = pSearch;
+ pSearch = pDel;
+ pDel = pAdd;
+ pAdd = pEdit;
+ pEdit = oMuligrid;
+ oMuligrid = elem;
+ elem = undefined;
+ }
+ pAdd = pAdd || {};
+ pEdit = pEdit || {};
+ pView = pView || {};
+ pDel = pDel || {};
+ pSearch = pSearch || {};
+ return this.each(function () {
+ var $t = this, p = $t.p, $self = $($t);
+ if (!$t.grid || p == null || ($t.nav && $(elem).find(".navtable").length > 0)) {
+ return; // error or the navigator bar already exists
+ }
+ // make new copy of the options oMuligrid and use it for ONE specific grid.
+ // p.navOptions can contains grid specific options
+ // we will don't modify the input options oMuligrid
+ var gridId = p.id,
+ o = $.extend(
+ {
+ edit: true,
+ add: true,
+ del: true,
+ search: true,
+ refresh: true,
+ refreshstate: "firstpage",
+ view: false,
+ closeOnEscape: true,
+ beforeRefresh: null,
+ afterRefresh: null,
+ cloneToTop: false,
+ hideEmptyPagerParts: true,
+ //jqModal: true,
+ alertwidth: 200,
+ alertheight: "auto",
+ alerttop: null,
+ //alertToTop: false,
+ removemodal: true,
+ alertleft: null,
+ alertzIndex: null,
+ iconsOverText: false
+ },
+ base.getGridRes.call($self, "nav"),
+ jgrid.nav || {},
+ p.navOptions || {},
+ oMuligrid || {}
+ );
+ // set default position depend of RTL/LTR direction of the grid
+ o.position = o.position || (p.direction === "rtl" ? "right" : "left");
+
+ var twd, tdw, gridIdEscaped = p.idSel, gboxSelector = p.gBox, commonIconClass = o.commonIconClass,
+ alertIDs = { themodal: "alertmod_" + gridId, modalhead: "alerthd_" + gridId, modalcontent: "alertcnt_" + gridId },
+ createModalAlert = function () {
+ return function () {
+ var documentElement = document.documentElement, w = window, left = 1024, top = 768,
+ offsetGbox = $self.closest(".ui-jqgrid").offset();
+ if ($("#" + jqID(alertIDs.themodal))[0] === undefined) {
+ if (!o.alerttop && !o.alertleft) {
+ if (w.innerWidth !== undefined) {
+ left = w.innerWidth;
+ top = w.innerHeight;
+ } else if (documentElement != null && documentElement.clientWidth !== undefined && documentElement.clientWidth !== 0) {
+ left = documentElement.clientWidth;
+ top = documentElement.clientHeight;
+ }
+ left = left / 2 - parseInt(o.alertwidth, 10) / 2 - offsetGbox.left + w.scrollX;
+ top = top / 2 - 25 - offsetGbox.top + w.scrollY;
+ }
+ jgrid.createModal.call($t, alertIDs,
+ "",
+ {
+ gbox: gboxSelector,
+ jqModal: o.jqModal,
+ drag: true,
+ resize: true,
+ caption: o.alertcap,
+ top: o.alerttop != null ? o.alerttop : top,
+ left: o.alertleft != null ? o.alertleft : left,
+ width: o.alertwidth,
+ height: o.alertheight,
+ closeOnEscape: o.closeOnEscape,
+ zIndex: o.alertzIndex,
+ removemodal: o.removemodal
+ },
+ p.gView,
+ $(gboxSelector)[0],
+ false);
+ }
+ jgrid.viewModal.call($t, "#" + jqID(alertIDs.themodal), {
+ gbox: gboxSelector,
+ toTop: o.alertToTop,
+ jqm: o.jqModal
+ });
+ var $close = $("#" + jqID(alertIDs.modalhead)).find(".ui-jqdialog-titlebar-close");
+ $close.attr({ tabindex: "0", href: "#", role: "button" });
+ setTimeout(function () {
+ $close.focus();
+ }, 50);
+ };
+ },
+ viewModalAlert = createModalAlert(),
+ navtbl,
+ clickOnEnter = function (e) {
+ var $focused;
+ if (e.which === 13) {
+ $focused = $(this).find(".ui-pg-button").filter(":focus");
+ if ($focused.length > 0) {
+ // $focused[0].id == "view_list" or "view_list_top"
+ var focusedId = $focused[0].id,
+ actionName = focusedId.substr(0,
+ $(this).closest(".ui-jqgrid-toppager").length > 0 ?
+ focusedId.length - gridId.length - 5 : // "_" + "_top"
+ focusedId.length - gridId.length - 1), // view "_"
+ gialogId = actionName + "mod" + p.id, // "viewmodlist"
+ visibleDailogIds = $(".ui-jqdialog").filter(":visible").map(function () { return this.id; });
+
+ if ($.inArray(gialogId, visibleDailogIds) < 0) {
+ // simulate click only if the dialog is not already opened
+ $focused.trigger("click");
+ return false;
+ }
+ }
+ }
+ },
+ hoverClasses = getGuiStateStyles.call($t, "hover"),
+ disabledClass = getGuiStateStyles.call($t, "disabled"),
+ navButtonClass = getGuiStyles.call($t, "navButton", "ui-pg-button");
+ if (!$t.grid) {
+ return; // error
+ }
+ // set modalAlert which can be used inside of
+ $t.modalAlert = viewModalAlert;
+ if (elem === undefined) {
+ if (p.pager) {
+ elem = p.pager;
+ if (p.toppager) {
+ o.cloneToTop = true; // add buttons to both pagers
+ }
+ } else if (p.toppager) {
+ elem = p.toppager;
+ }
+ }
+
+ var clone = 1, i, tbd, pgid, elemids, iPart, pagerTable, $pagerPart, pagerParts = ["left", "center", "right"],
+ navButtonDisabledClass = getGuiStyles.call($t, "navButton", "ui-pg-button" + " " + getGuiStateStyles.call($t, "disabled")),
+ sep = "
",
+ onHoverIn = function () {
+ if (!hasOneFromClasses(this, disabledClass)) {
+ $(this).addClass(hoverClasses);
+ }
+ },
+ onHoverOut = function () {
+ $(this).removeClass(hoverClasses);
+ },
+ onAdd = function () {
+ if (!hasOneFromClasses(this, disabledClass)) {
+ if ($.isFunction(o.addfunc)) {
+ o.addfunc.call($t, pAdd);
+ } else {
+ base.editGridRow.call($self, "new", pAdd);
+ }
+ }
+ return false;
+ },
+ editOrViewOfSelectedRow = function (func, methodName, param) {
+ if (!hasOneFromClasses(this, disabledClass)) {
+ var sr = p.selrow;
+ if (sr) {
+ if ($.isFunction(func)) {
+ func.call($t, sr, param);
+ } else {
+ base[methodName].call($self, sr, param);
+ }
+ } else {
+ viewModalAlert();
+ }
+ }
+ return false;
+ },
+ onEdit = function () {
+ return editOrViewOfSelectedRow.call(this, o.editfunc, "editGridRow", pEdit);
+ },
+ onView = function () {
+ return editOrViewOfSelectedRow.call(this, o.viewfunc, "viewGridRow", pView);
+ },
+ onDel = function () {
+ var dr;
+ if (!hasOneFromClasses(this, disabledClass)) {
+ if (p.multiselect) {
+ dr = p.selarrrow;
+ if (dr.length === 0) { dr = null; }
+ } else {
+ dr = p.selrow;
+ }
+ if (dr) {
+ if ($.isFunction(o.delfunc)) {
+ o.delfunc.call($t, dr, pDel);
+ } else {
+ base.delGridRow.call($self, dr, pDel);
+ }
+ } else {
+ viewModalAlert();
+ }
+ }
+ return false;
+ },
+ onSearch = function () {
+ if (!hasOneFromClasses(this, disabledClass)) {
+ if ($.isFunction(o.searchfunc)) {
+ o.searchfunc.call($t, pSearch);
+ } else {
+ base.searchGrid.call($self, pSearch);
+ }
+ }
+ return false;
+ },
+ onRefresh = function () {
+ if (!hasOneFromClasses(this, disabledClass)) {
+ if ($.isFunction(o.beforeRefresh)) { o.beforeRefresh.call($t); }
+ p.search = false;
+ p.resetsearch = true;
+ try {
+ if (o.refreshstate !== "currentfilter") {
+ p.postData.filters = "";
+ try {
+ $("#fbox_" + gridIdEscaped).jqFilter("resetFilter");
+ } catch (ignore) { }
+ if ($.isFunction($t.clearToolbar)) { $t.clearToolbar(false); }
+ }
+ } catch (ignore) { }
+ switch (o.refreshstate) {
+ case "firstpage":
+ $self.trigger("reloadGrid", [$.extend({}, o.reloadGridOptions || {}, { page: 1 })]);
+ break;
+ case "current":
+ case "currentfilter":
+ $self.trigger("reloadGrid", [$.extend({}, o.reloadGridOptions || {}, { current: true })]);
+ break;
+ }
+ if ($.isFunction(o.afterRefresh)) { o.afterRefresh.call($t); }
+ }
+ return false;
+ },
+ stdButtonActivation = function (name, id, onClick) {
+ var $button = $("
"),
+ iconClass = o[name + "icon"],
+ iconText = $.trim(o[name + "text"]);
+ $button.append("" + iconText + " " : "") +
+ "
");
+ $(navtbl).append($button);
+ $button.attr({ "title": o[name + "title"] || "", id: id || name + "_" + elemids })
+ .click(onClick)
+ .hover(onHoverIn, onHoverOut);
+ return $button;
+ };
+
+ if (o.cloneToTop && p.toppager) { clone = 2; }
+ for (i = 0; i < clone; i++) {
+ // we can set aria-activedescendant="idOfFirstButton" later
+ navtbl = $("");
+ if (i === 0) {
+ pgid = elem;
+ elemids = gridId;
+ if (pgid === p.toppager) {
+ elemids += "_top";
+ clone = 1;
+ }
+ } else {
+ pgid = p.toppager;
+ elemids = gridId + "_top";
+ }
+ if (o.add) {
+ stdButtonActivation("add", pAdd.id, onAdd);
+ }
+ if (o.edit) {
+ stdButtonActivation("edit", pEdit.id, onEdit);
+ }
+ if (o.view) {
+ stdButtonActivation("view", pView.id, onView);
+ }
+ if (o.del) {
+ stdButtonActivation("del", pDel.id, onDel);
+ }
+ if (o.add || o.edit || o.del || o.view) { $(navtbl).append(sep); }
+ if (o.search) {
+ tbd = stdButtonActivation("search", pSearch.id, onSearch);
+ if (pSearch.showOnLoad && pSearch.showOnLoad === true) {
+ $(tbd, navtbl).click();
+ }
+ }
+ if (o.refresh) {
+ stdButtonActivation("refresh", "", onRefresh);
+ }
+ // TODO use setWidthOfPagerTdWithPager or remove at all and use div structure with wrapping
+ tdw = $(".ui-jqgrid>.ui-jqgrid-view").css("font-size") || "11px";
+ $("body").append("
");
+ twd = $(navtbl).clone().appendTo("#testpg2").width();
+ $("#testpg2").remove();
+ $(pgid + "_" + o.position, pgid).append(navtbl);
+ if (o.hideEmptyPagerParts) {
+ for (iPart = 0; iPart < pagerParts.length; iPart++) {
+ if (pagerParts[iPart] !== o.position) {
+ $pagerPart = $(pgid + "_" + pagerParts[iPart], pgid);
+ if ($pagerPart.length === 0 || $pagerPart[0].childNodes.length === 0) {
+ $pagerPart.hide();
+ } else if ($pagerPart[0].childNodes.length === 1) {
+ pagerTable = $pagerPart[0].firstChild;
+ if ($(pagerTable).is("table.ui-pg-table") && (pagerTable.rows === 0 || pagerTable.rows[0].cells.length === 0)) {
+ $pagerPart.hide();
+ }
+ }
+ }
+ }
+ }
+ if (p._nvtd) {
+ if (twd > p._nvtd[0]) {
+ $(pgid + "_" + o.position, pgid).width(twd);
+ p._nvtd[0] = twd;
+ }
+ p._nvtd[1] = twd;
+ }
+ $t.nav = true;
+ navtbl.on("keydown.jqGrid", clickOnEnter);
+ }
+ $self.triggerHandler("jqGridResetFrozenHeights");
+ });
+ },
+ navButtonAdd: function (elem, oMuligrid) {
+ if (typeof elem === "object") {
+ oMuligrid = elem;
+ elem = undefined;
+ }
+ return this.each(function () {
+ var $t = this, p = $t.p;
+ if (!$t.grid) { return; }
+ var o = $.extend(
+ {
+ caption: "newButton",
+ title: "",
+ onClickButton: null,
+ position: "last",
+ iconsOverText: false
+ },
+ base.getGridRes.call($($t), "nav"),
+ jgrid.nav || {},
+ p.navOptions || {},
+ oMuligrid || {}
+ ),
+ id = o.id,
+ hoverClasses = getGuiStateStyles.call($t, "hover"),
+ disabledClass = getGuiStateStyles.call($t, "disabled"),
+ navButtonClass = getGuiStyles.call($t, "navButton", "ui-pg-button");
+ if (elem === undefined) {
+ if (p.pager) {
+ base.navButtonAdd.call($($t), p.pager, o);
+ if (p.toppager) {
+ elem = p.toppager;
+ if (id) {
+ id += "_top";
+ }
+ } else {
+ return;
+ }
+ } else if (p.toppager) {
+ elem = p.toppager;
+ }
+ }
+ if (typeof elem === "string" && elem.indexOf("#") !== 0) { elem = "#" + jqID(elem); }
+ var findnav = $(".navtable", elem), commonIconClass = o.commonIconClass;
+ if (findnav.length > 0) {
+ if (id && findnav.find("#" + jqID(id)).length > 0) { return; }
+ var tbd = $("
");
+ if (o.buttonicon.toString().toUpperCase() === "NONE") {
+ $(tbd).addClass(navButtonClass).append("" +
+ (o.caption ? "" + o.caption + " " : "") +
+ "
");
+ } else {
+ $(tbd).addClass(navButtonClass).append("" +
+ "" + o.caption + " " : "") +
+ "
");
+ }
+ if (id) { $(tbd).attr("id", id); }
+ if (o.position === "first" && findnav.children("div.ui-pg-button").length > 0) {
+ findnav.children("div.ui-pg-button").first().before(tbd);
+ } else {
+ findnav.append(tbd);
+ }
+ $(tbd, findnav)
+ .attr("title", o.title || "")
+ .click(function (e) {
+ if (!hasOneFromClasses(this, disabledClass)) {
+ if ($.isFunction(o.onClickButton)) { o.onClickButton.call($t, o, e); }
+ }
+ return false;
+ })
+ .hover(
+ function () {
+ if (!hasOneFromClasses(this, disabledClass)) {
+ $(this).addClass(hoverClasses);
+ }
+ },
+ function () { $(this).removeClass(hoverClasses); }
+ );
+ $($t).triggerHandler("jqGridResetFrozenHeights");
+ }
+ });
+ },
+ navSeparatorAdd: function (elem, o) {
+ o = $.extend({
+ sepclass: "ui-separator",
+ sepcontent: "",
+ position: "last"
+ }, o || {});
+ return this.each(function () {
+ if (!this.grid) { return; }
+ var $t = this, p = $t.p,
+ navButtonClass = getGuiStyles.call($t, "navButton", "ui-pg-button" + " " + getGuiStateStyles.call($t, "disabled"));
+
+ if (elem === undefined) {
+ if (p.pager) {
+ base.navSeparatorAdd.call($($t), p.pager, o);
+ if (p.toppager) {
+ elem = p.toppager;
+ } else {
+ return;
+ }
+ } else if (p.toppager) {
+ elem = p.toppager;
+ }
+ }
+ if (typeof elem === "string" && elem.indexOf("#") !== 0) { elem = "#" + jqID(elem); }
+ var $nav = $(".navtable", elem);
+ if ($nav.length > 0) {
+ var sep = "
";
+ if (o.position === "first") {
+ if ($nav.children("div.ui-pg-button").length === 0) {
+ $nav.append(sep);
+ } else {
+ $nav.children("div.ui-pg-button").first().before(sep);
+ }
+ } else {
+ $nav.append(sep);
+ }
+ }
+ });
+ },
+ GridToForm: function (rowid, formid) {
+ return this.each(function () {
+ var $t = this, i, $field, iField, $fieldi;
+ if (!$t.grid) { return; }
+ var rowdata = base.getRowData.call($($t), rowid);
+ if (rowdata) {
+ for (i in rowdata) {
+ if (rowdata.hasOwnProperty(i)) {
+ $field = $("[name=" + jqID(i) + "]", formid);
+ if ($field.is("input:radio") || $field.is("input:checkbox")) {
+ for (iField = 0; iField < $field.length; iField++) {
+ $fieldi = $($field[iField]);
+ $fieldi.prop("checked", $fieldi.val() === String(rowdata[i]));
+ }
+ } else {
+ // this is very slow on big table and form.
+ $field.val(isEmptyString(rowdata[i]) ? "" : rowdata[i]);
+ }
+ }
+ }
+ }
+ });
+ },
+ FormToGrid: function (rowid, formid, mode, position) {
+ return this.each(function () {
+ var $t = this;
+ if (!$t.grid) { return; }
+ if (!mode) { mode = "set"; }
+ if (!position) { position = "first"; }
+ var fields = $(formid).serializeArray();
+ var griddata = {};
+ $.each(fields, function (i, field) {
+ griddata[field.name] = field.value;
+ });
+ if (mode === "add") {
+ base.addRowData.call($($t), rowid, griddata, position);
+ } else if (mode === "set") {
+ base.setRowData.call($($t), rowid, griddata);
+ }
+ });
+ }
+ });
+ // end module grid.formedit
+
+ // begin module grid.grouping
+ jgrid.extend({
+ groupingSetup: function () {
+ return this.each(function () {
+ var $t = this, i, j, cml, p = $t.p, colModel = p.colModel, grp = p.groupingView, cm, summary,
+ emptyFormatter = function () {
+ return "";
+ };
+ if (grp !== null && ((typeof grp === "object") || $.isFunction(grp))) {
+ if (!grp.groupField.length) {
+ p.grouping = false;
+ } else {
+ if (grp.visibiltyOnNextGrouping === undefined) {
+ grp.visibiltyOnNextGrouping = [];
+ }
+
+ grp.lastvalues = [];
+ if (!grp._locgr) {
+ grp.groups = [];
+ }
+ grp.counters = [];
+ for (i = 0; i < grp.groupField.length; i++) {
+ if (!grp.groupOrder[i]) {
+ grp.groupOrder[i] = "asc";
+ }
+ if (!grp.groupText[i]) {
+ grp.groupText[i] = "{0}";
+ }
+ if (typeof grp.groupColumnShow[i] !== "boolean") {
+ grp.groupColumnShow[i] = true;
+ }
+ if (typeof grp.groupSummary[i] !== "boolean") {
+ grp.groupSummary[i] = false;
+ }
+ if (!grp.groupSummaryPos[i]) {
+ grp.groupSummaryPos[i] = "footer";
+ }
+ // TODO: allow groupField be from additionalProperties
+ // and not only from colModel
+ cm = colModel[p.iColByName[grp.groupField[i]]];
+ if (grp.groupColumnShow[i] === true) {
+ grp.visibiltyOnNextGrouping[i] = true;
+ if (cm != null && cm.hidden === true) {
+ base.showCol.call($($t), grp.groupField[i]);
+ }
+ } else {
+ grp.visibiltyOnNextGrouping[i] = $("#" + jgrid.jqID(p.id + "_" + grp.groupField[i])).is(":visible");
+ if (cm != null && cm.hidden !== true) {
+ base.hideCol.call($($t), grp.groupField[i]);
+ }
+ }
+ }
+ grp.summary = [];
+ if (grp.hideFirstGroupCol) {
+ grp.formatDisplayField[0] = function (v) {
+ return v;
+ };
+ }
+ for (j = 0, cml = colModel.length; j < cml; j++) {
+ cm = colModel[j];
+ if (grp.hideFirstGroupCol) {
+ if (!cm.hidden && grp.groupField[0] === cm.name) {
+ cm.formatter = emptyFormatter;
+ }
+ }
+ if (cm.summaryType) {
+ summary = {
+ nm: cm.name,
+ st: cm.summaryType,
+ v: "",
+ sr: cm.summaryRound,
+ srt: cm.summaryRoundType || "round"
+ };
+ if (cm.summaryDivider) {
+ summary.sd = cm.summaryDivider;
+ summary.vd = "";
+ }
+ grp.summary.push(summary);
+ }
+ }
+ }
+ } else {
+ p.grouping = false;
+ }
+ });
+ },
+ groupingPrepare: function (record, irow) {
+ this.each(function () {
+ var $t = this, p = $t.p, grp = p.groupingView, groups = grp.groups, counters = grp.counters,
+ lastvalues = grp.lastvalues, isInTheSameGroup = grp.isInTheSameGroup, groupLength = grp.groupField.length,
+ i, j, keys, newGroup, counter, fieldName, v, displayName, displayValue, changed = false,
+ groupingCalculationsHandler = base.groupingCalculations.handler, key,
+ buildSummary = function () {
+ var iSummary, summary, st;
+ for (iSummary = 0; iSummary < counter.summary.length; iSummary++) {
+ summary = counter.summary[iSummary];
+ st = $.isArray(summary.st) ? summary.st[newGroup.idx] : summary.st;
+ if ($.isFunction(st)) {
+ summary.v = st.call($t, summary.v, summary.nm, record, newGroup);
+ } else {
+ summary.v = groupingCalculationsHandler.call($($t), st, summary.v, summary.nm, summary.sr, summary.srt, record);
+ if (st.toLowerCase() === "avg" && summary.sd) {
+ summary.vd = groupingCalculationsHandler.call($($t), st, summary.vd, summary.sd, summary.sr, summary.srt, record);
+ }
+ }
+ }
+ return counter.summary;
+ },
+ normilizeValue = function (value, cmOrPropName) {
+ if (value == null && grp.useDefaultValuesOnGrouping) {
+ var cm = p.iColByName[cmOrPropName] !== undefined ?
+ p.colModel[p.iColByName[cmOrPropName]] :
+ p.additionalProperties[p.iPropByName[cmOrPropName]],
+ defaultValue;
+
+ if (cm != null && cm.formatter != null) {
+ if (cm.formatoptions != null && cm.formatoptions.defaultValue !== undefined) {
+ value = cm.formatoptions.defaultValue;
+ } else if (typeof cm.formatter === "string") {
+ defaultValue = $($t).jqGrid("getGridRes", "formatter." + cm.formatter + ".defaultValue");
+ if (defaultValue !== undefined) {
+ value = defaultValue;
+ }
+ }
+ }
+ }
+ return value;
+ };
+
+ for (i = 0; i < groupLength; i++) {
+ fieldName = grp.groupField[i];
+ v = normilizeValue(record[fieldName], fieldName);
+ key = v;
+ displayName = grp.displayField[i];
+ displayValue = displayName == null ?
+ null :
+ normilizeValue(record[displayName], displayName);
+
+ if (displayValue == null) {
+ displayValue = v;
+ }
+ if (v !== undefined) {
+ keys = [];
+ for (j = 0; j <= i; j++) {
+ keys.push(record[grp.groupField[j]]);
+ }
+ newGroup = {
+ idx: i, // index in grp.groupField array
+ dataIndex: fieldName,
+ value: v,
+ displayValue: displayValue,
+ startRow: irow,
+ cnt: 1,
+ keys: keys,
+ summary: []
+ };
+ counter = {
+ cnt: 1,
+ pos: groups.length,
+ summary: $.extend(true, [], grp.summary)
+ };
+ if (irow === 0) {
+ // First record always starts a new group
+ groups.push(newGroup);
+ lastvalues[i] = v;
+ counters[i] = counter;
+ } else {
+ if (typeof v !== "object" && ($.isArray(isInTheSameGroup) && $.isFunction(isInTheSameGroup[i]) ? !isInTheSameGroup[i].call($t, lastvalues[i], v, i, grp) : lastvalues[i] !== v)) {
+ // This record is not in same group as previous one
+ groups.push(newGroup);
+ lastvalues[i] = v;
+ changed = true;
+ counters[i] = counter;
+ } else {
+ if (changed) {
+ // This group has changed because an earlier group changed.
+ groups.push(newGroup);
+ lastvalues[i] = v;
+ counters[i] = counter;
+ } else {
+ counter = counters[i];
+ counter.cnt += 1;
+ groups[counter.pos].cnt = counter.cnt;
+ }
+ }
+ }
+ groups[counter.pos].summary = buildSummary();
+ for (j = counter.pos - 1; j >= 0; j--) {
+ // find the parent group (the grouping header)
+ if (groups[j].idx < groups[counter.pos].idx) {
+ groups[counter.pos].parentGroupIndex = j;
+ groups[counter.pos].parentGroup = groups[j];
+ break;
+ }
+ }
+ }
+ }
+ //gdata.push( rData );
+ });
+ return this;
+ },
+ getGroupHeaderIndex: function (hid, clickedElem) {
+ var $self = this, self = $self[0], p = self.p,
+ $tr = clickedElem ?
+ $(clickedElem).closest("tr.jqgroup") :
+ $("#" + jgrid.jqID(hid)),
+ groupLevel = parseInt($tr.data("jqgrouplevel"), 10),
+ hPrefix = p.id + "ghead_" + groupLevel + "_";
+ if (isNaN(groupLevel) || !$tr.hasClass("jqgroup") || hid.length <= hPrefix.length) {
+ return -1;
+ }
+ return parseInt(hid.substring(hPrefix.length), 10);
+ },
+ groupingToggle: function (hid, clickedElem) {
+ this.each(function () {
+ var $t = this, p = $t.p, grp = p.groupingView,
+ minusClasses = grp.minusicon, plusClasses = grp.plusicon,
+ $tr = clickedElem ?
+ $(clickedElem).closest("tr.jqgroup") :
+ $("#" + jgrid.jqID(hid)),
+ getGroupHeaderIcon = function ($trElem) {
+ return $trElem.find(">td>span." + "tree-wrap");
+ },
+ itemGroupingLevel, iRowStart, showDataRowsOnExpending = true,
+ $groupIcon, collapsed = false, rowsToHideOrShow = [],
+ addToHideOrShow = function ($elem) {
+ var i, l = $elem.length;
+ for (i = 0; i < l; i++) {
+ rowsToHideOrShow.push($elem[i]);
+ }
+ },
+ num = parseInt($tr.data("jqgrouplevel"), 10);
+
+ if (p.frozenColumns && $tr.length > 0) {
+ // always get row from non-frozen column
+ iRowStart = $tr[0].rowIndex;
+ $tr = $($t.rows[iRowStart]);
+ $tr = $tr.add($t.grid.fbRows[iRowStart]);
+ }
+ $groupIcon = getGroupHeaderIcon($tr);
+
+ if (jgrid.hasAllClasses($groupIcon, minusClasses)) {
+ $groupIcon.removeClass(minusClasses).addClass(plusClasses);
+ collapsed = true;
+ } else {
+ $groupIcon.removeClass(plusClasses).addClass(minusClasses);
+ }
+ for ($tr = $tr.next(); $tr.length; $tr = $tr.next()) {
+ if ($tr.hasClass("jqfoot")) {
+ itemGroupingLevel = parseInt($tr.data("jqfootlevel"), 10);
+ if (collapsed) {
+ // hide all till the summary row of the same level.
+ // don't hide the summary row if grp.showSummaryOnHide === true
+ itemGroupingLevel = parseInt($tr.data("jqfootlevel"), 10);
+ if ((!grp.showSummaryOnHide && itemGroupingLevel === num) || itemGroupingLevel > num) {
+ addToHideOrShow($tr);
+ }
+ // stop hiding of rows if the footer of parent group are found
+ if (itemGroupingLevel < num) { break; }
+ } else {
+ if (itemGroupingLevel === num || (grp.showSummaryOnHide && itemGroupingLevel === num + 1)) {
+ addToHideOrShow($tr);
+ }
+ if (itemGroupingLevel <= num) { break; }
+ }
+ } else if ($tr.hasClass("jqgroup")) {
+ itemGroupingLevel = parseInt($tr.data("jqgrouplevel"), 10);
+ if (collapsed) {
+ // stop hiding of rows if the grouping header of the next group
+ // of the same (or higher) level are found
+ if (itemGroupingLevel <= num) { break; }
+
+ addToHideOrShow($tr);
+ } else {
+ // stop next grouping header of the same lever are found
+ if (itemGroupingLevel <= num) { break; }
+ if (itemGroupingLevel === num + 1) {
+ // one should display subgroupes in collaped form
+ getGroupHeaderIcon($tr).removeClass(minusClasses).addClass(plusClasses);
+ addToHideOrShow($tr);
+ }
+ // one need hide all data if subgroup is found
+ showDataRowsOnExpending = false;
+ }
+ } else { // data
+ // we set currently no information about the level of data
+ // se we use showDataRowsOnExpending variable which will be
+ // used during expanding of data
+ if (collapsed || showDataRowsOnExpending) {
+ // grouping data need be displayed only
+ // if the last level group with data (no subgroups)
+ // is expanded
+ addToHideOrShow($tr);
+ }
+ }
+ }
+ //$(rowsToHideOrShow)[collapsed ? "hide" : "show"]();
+ $(rowsToHideOrShow).css("display", collapsed ? "none" : "");
+ // fix position of elements of frozen divs
+ if (p.frozenColumns) {
+ $($t).triggerHandler("jqGridResetFrozenHeights", [{
+ header: {
+ resizeDiv: false,
+ resizedRows: {
+ iRowStart: -1, // -1 means don't recalculate heights or rows
+ iRowEnd: -1
+ }
+ },
+ resizeFooter: false,
+ body: {
+ resizeDiv: true,
+ resizedRows: {
+ iRowStart: iRowStart,
+ iRowEnd: ($tr.length ? $tr[0].rowIndex - 1 : -1)
+ }
+ }
+ }]);
+ }
+
+ // recalculate the width because vertical scrollbar can
+ // appears/disappears after expanding/collapsing
+ $t.fixScrollOffsetAndhBoxPadding();
+ $($t).triggerHandler("jqGridGroupingClickGroup", [hid, collapsed]);
+ if ($.isFunction(p.onClickGroup)) {
+ p.onClickGroup.call($t, hid, collapsed);
+ }
+ });
+ return false;
+ },
+ groupingRender: function (grdata, rn) {
+ // input parameter grdata is array of strings, which are either opening element
+ // or full HTML fragment (outer HTML) of element, inclusive the closing tag
+ // or it contains the closing tag. The array grdata contains HTML fragments
+ // of all rows from the current group.
+ // The exact contain of the grdata is the following:
+ // "" - the opening tag of the first row of the group
+ // "... " - the irst cell of the first row
+ // "... " - the second cell of the first row
+ // ...
+ // "... " - the last cell of the first row
+ // " " - closing tag of the first row of the group
+ // "" - the opening tag of the second row of the group
+ // ... - all elements of the second row
+ // " " - closing tag of the second row of the group
+ // ...
+ // "" - the opening tag of the last row of the group
+ // ... - all elements of the last row
+ // " " - closing tag of the last row of the group
+ // The input parameter rn corresponds to p.rowNum in the most cases.
+ var str = "", $t = this[0], p = $t.p, toEnd = 0, cp = [],
+ grp = p.groupingView, sumreverse = $.makeArray(grp.groupSummary),
+ groupLength = grp.groupField.length, groups = grp.groups, colModel = p.colModel,
+ cmLength = colModel.length, page = p.page,
+ eventNames = "jqGridShowHideCol.groupingRender",
+ getGridRowStyles = function (classes) {
+ return base.getGuiStyles.call($t, "gridRow", classes);
+ },
+ jqgroupClass = getGridRowStyles("jqgroup ui-row-" + p.direction),
+ jqfootClass = getGridRowStyles("jqfoot ui-row-" + p.direction);
+
+ function buildSummaryTd(iEndGroup, offset, g, foffset, iconHtml) {
+ var fdata = groups[iEndGroup], i, groupCount, strTd = "", tmpdata, colSpan, align, vv,
+ madeHidden, nMakeHidden = 0, iSummary, summary, cm, iCol, summaryType, summaryTpl,
+ isColumnForIconNotFound = true;
+
+ if (offset !== 0 && groups[iEndGroup].idx !== 0) {
+ for (i = iEndGroup; i >= 0; i--) {
+ if (groups[i].idx === groups[iEndGroup].idx - offset) {
+ fdata = groups[i];
+ break;
+ }
+ }
+ }
+ groupCount = fdata.cnt;
+
+ for (iCol = (iconHtml === undefined ? foffset : 0); iCol < cmLength; iCol++) {
+ tmpdata = " ";
+ cm = colModel[iCol];
+ for (iSummary = 0; iSummary < fdata.summary.length; iSummary++) {
+ summary = fdata.summary[iSummary];
+ summaryType = $.isArray(summary.st) ? summary.st[g.idx] : summary.st;
+ summaryTpl = $.isArray(cm.summaryTpl) ? cm.summaryTpl[g.idx] : (cm.summaryTpl || "{0}");
+ if (summary.nm === cm.name) {
+ if (typeof summaryType === "string" && summaryType.toLowerCase() === "avg") {
+ if (summary.sd && summary.vd) {
+ summary.v = (summary.v / summary.vd);
+ } else if (summary.v && groupCount > 0) {
+ summary.v = (summary.v / groupCount);
+ }
+ }
+ try {
+ summary.groupCount = fdata.cnt;
+ summary.groupIndex = fdata.dataIndex;
+ summary.groupValue = fdata.value;
+ vv = $t.formatter("", summary.v, iCol, summary);
+ } catch (ef) {
+ vv = summary.v;
+ }
+ tmpdata = jgrid.format(summaryTpl, vv);
+ if (cm.summaryFormat) {
+ tmpdata = cm.summaryFormat.call($t, g, tmpdata, vv, cm, summary);
+ }
+ break;
+ }
+ }
+ colSpan = false;
+ align = false;
+ if (iconHtml !== undefined && isColumnForIconNotFound) {
+ if (!cm.hidden) {
+ // the icon need be placed in the first non-hidden column
+ tmpdata = iconHtml;
+ isColumnForIconNotFound = false;
+ if (foffset > 1) {
+ colSpan = true;
+ // if foffset > 1 then the next foffset-1 non-hidden columns
+ // must be displayed hidden.
+ nMakeHidden = foffset - 1;
+ }
+ // the icon in the column header must be left aligned
+ align = cm.align; // save the original align value
+ cm.align = p.direction === "rtl" ? "right" : "left";
+ grp.iconColumnName = cm.name;
+ }
+ }
+ madeHidden = false;
+ if (nMakeHidden > 0 && !cm.hidden && tmpdata === " ") {
+ madeHidden = true;
+ if (align) {
+ cm.align = align; // restore the original align value
+ }
+ nMakeHidden--;
+ continue;
+ }
+ strTd += "" + tmpdata + " ";
+ colSpan = false;
+ if (align) {
+ cm.align = align; // restore the original align value
+ }
+ if (madeHidden) {
+ cm.hidden = false;
+ nMakeHidden--;
+ }
+ }
+ return strTd;
+ }
+
+ // TODO: allow groupField be from additionalProperties
+ // and not only from colModel
+ $.each(colModel, function (i, n) {
+ var iGroup;
+ for (iGroup = 0; iGroup < groupLength; iGroup++) {
+ if (grp.groupField[iGroup] === n.name) {
+ cp[iGroup] = i;
+ break;
+ }
+ }
+ });
+
+ sumreverse.reverse();
+ $.each(groups, function (i, n) {
+ var gv, clid = p.id + "ghead_" + n.idx, hid = clid + "_" + i,
+ groupCollapse = $.isFunction(grp.groupCollapse) ?
+ grp.groupCollapse.call($t, { group: n, rowid: hid }) :
+ grp.groupCollapse,
+ jj, kk, ik, colspan = 1, offset = 0, sgr, gg, end, grpTextStr,
+ leaf = groupLength - 1 === n.idx,
+ parentGroupCollapse = n.parentGroup != null ?
+ n.parentGroup.collapsed :
+ false,
+ icon = "";
+ grpTextStr = $.isFunction(grp.groupText[n.idx]) ?
+ grp.groupText[n.idx].call($t, gv, n.cnt, n.summary) :
+ jgrid.template(grp.groupText[n.idx], gv, n.cnt, n.summary);
+ if (typeof grpTextStr !== "string" && typeof grpTextStr !== "number") {
+ grpTextStr = gv;
+ }
+ if (grp.groupSummaryPos[n.idx] === "header") {
+ colspan = 1;
+ if (colModel[0].name === "cb" || colModel[1].name === "cb") {
+ colspan++;
+ }
+ if (colModel[0].name === "subgrid" || colModel[1].name === "subgrid") {
+ colspan++;
+ }
+ str += buildSummaryTd(i, 0, n, colspan, icon + "" + grpTextStr + " ");
+ } else {
+ str += "" + icon + grpTextStr + " ";
+ }
+ str += " ";
+ if (leaf) {
+ gg = groups[i + 1];
+ sgr = n.startRow;
+ end = gg !== undefined ? gg.startRow : groups[i].startRow + groups[i].cnt;
+ if (grp._locgr) {
+ offset = (page - 1) * rn;
+ if (offset > n.startRow) {
+ sgr = offset;
+ }
+ }
+ for (kk = sgr; kk < end; kk++) {
+ if (!grdata[kk - offset]) {
+ break;
+ }
+ str += grdata[kk - offset].join("");
+ }
+ if (grp.groupSummaryPos[n.idx] !== "header") {
+ if (gg !== undefined) {
+ for (jj = 0; jj < grp.groupField.length; jj++) {
+ if (gg.dataIndex === grp.groupField[jj]) {
+ break;
+ }
+ }
+ toEnd = grp.groupField.length - jj;
+ }
+ for (ik = 0; ik < toEnd; ik++) {
+ if (!sumreverse[ik]) {
+ continue;
+ }
+ str += "";
+ }
+ toEnd = jj;
+ }
+ }
+ });
+ this.off(eventNames)
+ .on(eventNames, function () { //e, show, cmName, iColShow) {
+ // TODO fix the code after resorting columns
+ var iCol = p.iColByName[grp.iconColumnName], iRow, row, iColNew, i; //$cellData;
+ if ($.inArray("header", grp.groupSummaryPos) >= 0) {
+ for (i = 0; i < colModel.length; i++) {
+ if (!colModel[i].hidden) {
+ iColNew = i;
+ break;
+ }
+ }
+ if (iColNew === undefined || iCol === iColNew) { return; }
+
+ for (iRow = 0; iRow < $t.rows.length; iRow++) {
+ row = $t.rows[iRow];
+ if ($(row).hasClass("jqgroup")) {
+ /*$cellData = $(row.cells[iCol]).children(".cell-wrapper").detach();
+ $.wrapInner(row.cells[iColNew], function () {//"" + this.nodeValue + " ";
+ });
+ row.cells[iColNew]
+ $cellData = $(row.cells[iCol]).children(".cell-wrapper").detach();
+ $(row.cells[iCol]).html($(row.cells[iCol]).children("").html());*/
+ $(row.cells[iColNew]).html(row.cells[iCol].innerHTML);
+ $(row.cells[iCol]).html(" ");
+ }
+ }
+ grp.iconColumnName = colModel[iColNew].name;
+ }
+ });
+ return str;
+ },
+ groupingGroupBy: function (name, options) {
+ return this.each(function () {
+ var $t = this, p = $t.p, grp = p.groupingView, i, cm;
+ if (typeof name === "string") {
+ name = [name];
+ }
+ p.grouping = true;
+ grp._locgr = false;
+ //Set default, in case visibilityOnNextGrouping is undefined
+ if (grp.visibiltyOnNextGrouping === undefined) {
+ grp.visibiltyOnNextGrouping = [];
+ }
+ // show previous hidden groups if they are hidden and weren't removed yet
+ for (i = 0; i < grp.groupField.length; i++) {
+ cm = p.colModel[p.iColByName[grp.groupField[i]]];
+ if (!grp.groupColumnShow[i] && grp.visibiltyOnNextGrouping[i] && cm != null && cm.hidden === true) {
+ base.showCol.call($($t), grp.groupField[i]);
+ }
+ }
+ // set visibility status of current group columns on next grouping
+ for (i = 0; i < name.length; i++) {
+ grp.visibiltyOnNextGrouping[i] = $(p.idSel + "_" + jgrid.jqID(name[i])).is(":visible");
+ }
+ p.groupingView = $.extend(p.groupingView, options || {});
+ grp.groupField = name;
+ $($t).trigger("reloadGrid");
+ });
+ },
+ groupingRemove: function (current) {
+ return this.each(function () {
+ var $t = this, p = $t.p, tbody = $t.tBodies[0], grp = p.groupingView, i;
+ if (current === undefined) {
+ current = true;
+ }
+ p.grouping = false;
+ if (current === true) {
+ // show previous hidden groups if they are hidden and weren't removed yet
+ for (i = 0; i < grp.groupField.length; i++) {
+ if (!grp.groupColumnShow[i] && grp.visibiltyOnNextGrouping[i]) {
+ base.showCol.call($($t), grp.groupField);
+ }
+ }
+ $("tr.jqgroup, tr.jqfoot", tbody).remove();
+ $("tr.jqgrow", tbody).filter(":hidden").show();
+ } else {
+ $($t).trigger("reloadGrid");
+ }
+ });
+ },
+ groupingCalculations: {
+ handler: function (fn, v, field, round, roundType, rc) {
+ var funcs = {
+ sum: function () {
+ return parseFloat(v || 0) + parseFloat((rc[field] || 0));
+ },
+
+ min: function () {
+ if (v === "") {
+ return parseFloat(rc[field] || 0);
+ }
+ return Math.min(parseFloat(v), parseFloat(rc[field] || 0));
+ },
+
+ max: function () {
+ if (v === "") {
+ return parseFloat(rc[field] || 0);
+ }
+ return Math.max(parseFloat(v), parseFloat(rc[field] || 0));
+ },
+
+ count: function () {
+ if (v === "") {
+ v = 0;
+ }
+ if (rc.hasOwnProperty(field)) {
+ return v + 1;
+ }
+ return 0;
+ },
+
+ avg: function () {
+ // the same as sum, but at end we divide it
+ // so use sum instead of duplicating the code (?)
+ return funcs.sum();
+ }
+ },
+ res,
+ mul;
+
+ if (!funcs[fn]) {
+ throw ("jqGrid Grouping No such method: " + fn);
+ }
+ res = funcs[fn]();
+
+ if (round != null) {
+ if (roundType === "fixed") {
+ res = res.toFixed(round);
+ } else {
+ mul = Math.pow(10, round);
+ res = Math.round(res * mul) / mul;
+ }
+ }
+
+ return res;
+ }
+ }
+ });
+ // end module grid.grouping
+
+ /**
+ * jqGrid extension for constructing Grid Data from external file
+ * Tony Tomov tony@trirand.com, http://trirand.com/blog/
+ * Dual licensed under the MIT and GPL licenses:
+ * http://www.opensource.org/licenses/mit-license.php
+ * http://www.gnu.org/licenses/gpl-2.0.html
+ **/
+ // begin module grid.import
+ $.jgrid.extend({
+ jqGridImport: function (o) {
+ o = $.extend({
+ imptype: "xml", // xml, json, xmlstring, jsonstring
+ impstring: "",
+ impurl: "",
+ mtype: "GET",
+ impData: {},
+ xmlGrid: {
+ config: "roots>grid",
+ data: "roots>rows"
+ },
+ jsonGrid: {
+ config: "grid",
+ data: "data"
+ },
+ ajaxOptions: {}
+ }, o || {});
+ return this.each(function () {
+ var $t = this,
+ xmlConvert = function (xml, options) {
+ var cnfg = $(options.xmlGrid.config, xml)[0], xmldata = $(options.xmlGrid.data, xml)[0], jstr, jstr1, key, svdatatype;
+ if (xmlJsonClass.xml2json) {
+ jstr = xmlJsonClass.xml2json(cnfg, " ");
+ jstr = $.parseJSON(jstr);
+ for (key in jstr) {
+ if (jstr.hasOwnProperty(key)) {
+ jstr1 = jstr[key];
+ }
+ }
+ if (jstr1 !== undefined) {
+ if (xmldata) {
+ // save the datatype
+ svdatatype = jstr.grid.datatype;
+ jstr.grid.datatype = "xmlstring";
+ jstr.grid.datastr = xml;
+ $($t).jqGrid(jstr1).jqGrid("setGridParam", { datatype: svdatatype });
+ } else {
+ $($t).jqGrid(jstr1);
+ }
+ }
+ } else {
+ (jgrid.defaults != null && $.isFunction(jgrid.defaults.fatalError) ? jgrid.defaults.fatalError : alert)("xml2json or parse are not present");
+ }
+ },
+ jsonConvert = function (jsonstr, options) {
+ if (jsonstr && typeof jsonstr === "string") {
+ var json = $.parseJSON(jsonstr),
+ gprm = json[options.jsonGrid.config],
+ jdata = json[options.jsonGrid.data], svdatatype;
+
+ if (jdata) {
+ svdatatype = gprm.datatype;
+ gprm.datatype = "jsonstring";
+ gprm.datastr = jdata;
+ $($t).jqGrid(gprm).jqGrid("setGridParam", { datatype: svdatatype });
+ } else {
+ $($t).jqGrid(gprm);
+ }
+ }
+ },
+ xmld;
+ switch (o.imptype) {
+ case "xml":
+ $.ajax($.extend({
+ url: o.impurl,
+ type: o.mtype,
+ data: o.impData,
+ dataType: "xml",
+ context: o,
+ complete: function (jqXHR) {
+ if ((jqXHR.status < 300 || jqXHR.status === 304) && (jqXHR.status !== 0 || jqXHR.readyState !== 4)) {
+ xmlConvert(jqXHR.responseXML, this);
+ $($t).triggerHandler("jqGridImportComplete", [jqXHR, this]);
+ if ($.isFunction(this.importComplete)) {
+ this.importComplete(jqXHR);
+ }
+ }
+ }
+ }, o.ajaxOptions));
+ break;
+ case "xmlstring":
+ // we need to make just the conversion and use the same code as xml
+ if (o.impstring && typeof o.impstring === "string") {
+ xmld = $.parseXML(o.impstring);
+ if (xmld) {
+ xmlConvert(xmld, o);
+ $($t).triggerHandler("jqGridImportComplete", [xmld, o]);
+ if ($.isFunction(o.importComplete)) {
+ o.importComplete(xmld);
+ }
+ o.impstring = null;
+ }
+ }
+ break;
+ case "json":
+ $.ajax($.extend({
+ url: o.impurl,
+ type: o.mtype,
+ data: o.impData,
+ dataType: "json",
+ context: o,
+ complete: function (jqXHR) {
+ try {
+ if ((jqXHR.status < 300 || jqXHR.status === 304) && (jqXHR.status !== 0 || jqXHR.readyState !== 4)) {
+ jsonConvert(jqXHR.responseText, this);
+ $($t).triggerHandler("jqGridImportComplete", [jqXHR, this]);
+ if ($.isFunction(this.importComplete)) {
+ this.importComplete(jqXHR);
+ }
+ }
+ } catch (ignore) { }
+ }
+ }, o.ajaxOptions));
+ break;
+ case "jsonstring":
+ if (o.impstring && typeof o.impstring === "string") {
+ jsonConvert(o.impstring, o);
+ $($t).triggerHandler("jqGridImportComplete", [o.impstring, o]);
+ if ($.isFunction(o.importComplete)) {
+ o.importComplete(o.impstring);
+ }
+ o.impstring = null;
+ }
+ break;
+ }
+ });
+ },
+ jqGridExport: function (o) {
+ o = $.extend({
+ exptype: "xmlstring",
+ root: "grid",
+ ident: "\t"
+ }, o || {});
+ var ret = null;
+ this.each(function () {
+ if (!this.grid) {
+ return;
+ }
+ var key, gprm = $.extend(true, {}, $(this).jqGrid("getGridParam"));
+ // we need to check for:
+ // 1.multiselect, 2.subgrid 3. treegrid and remove the unneded columns from colNames
+ if (gprm.rownumbers) {
+ gprm.colNames.splice(0, 1);
+ gprm.colModel.splice(0, 1);
+ }
+ if (gprm.multiselect) {
+ gprm.colNames.splice(0, 1);
+ gprm.colModel.splice(0, 1);
+ }
+ if (gprm.subGrid) {
+ gprm.colNames.splice(0, 1);
+ gprm.colModel.splice(0, 1);
+ }
+ gprm.knv = null;
+ if (gprm.treeGrid) {
+ for (key in gprm.treeReader) {
+ if (gprm.treeReader.hasOwnProperty(key)) {
+ gprm.colNames.splice(gprm.colNames.length - 1);
+ gprm.colModel.splice(gprm.colModel.length - 1);
+ }
+ }
+ }
+ switch (o.exptype) {
+ case "xmlstring":
+ ret = "<" + o.root + ">" + xmlJsonClass.json2xml(gprm, o.ident) + "";
+ break;
+ case "jsonstring":
+ ret = "{" + xmlJsonClass.toJson(gprm, o.root, o.ident, false) + "}";
+ if (gprm.postData.filters !== undefined) {
+ ret = ret.replace(/filters":"/, "filters\":");
+ ret = ret.replace(/\}\]\}"/, "}]}");
+ }
+ break;
+ }
+ });
+ return ret;
+ },
+ excelExport: function (o) {
+ o = $.extend({
+ exptype: "remote",
+ url: null,
+ oper: "oper",
+ tag: "excel",
+ exportOptions: {}
+ }, o || {});
+ return this.each(function () {
+ var pdata;
+ if (!this.grid) {
+ return;
+ }
+ if (o.exptype === "remote") {
+ pdata = $.extend({}, this.p.postData, o.exportOptions);
+ pdata[o.oper] = o.tag;
+ window.location = o.url + (o.url != null && o.url.indexOf("?") >= 0 ? "&" : "?") + $.param(pdata);
+ }
+ });
+ }
+ });
+ // end module grid.import
+
+ /**
+ * jqGrid extension for manipulating Grid Data
+ * Copyright (c) 2008-2014, Tony Tomov, tony@trirand.com, http://trirand.com/blog/
+ * Copyright (c) 2014-2017, Oleg Kiriljuk, oleg.kiriljuk@ok-soft-gmbh.com
+ * Dual licensed under the MIT and GPL licenses:
+ * http://www.opensource.org/licenses/mit-license.php
+ * http://www.gnu.org/licenses/gpl-2.0.html
+ **/
+ // begin module grid.inlinedit
+ var editFeedback = function (o) {
+ var args = $.makeArray(arguments).slice(1);
+ args.unshift("");
+ args.unshift("Inline");
+ args.unshift(o);
+ return jgrid.feedback.apply(this, args);
+ };
+ jgrid.inlineEdit = jgrid.inlineEdit || {};
+ jgrid.extend({
+ //Editing
+ editRow: function (rowid, keys, oneditfunc, successfunc, url, extraparam, aftersavefunc, errorfunc, afterrestorefunc, beforeEditRow) {
+ // Compatible mode old versions
+ var oMuligrid = {}, args = $.makeArray(arguments).slice(1);
+
+ if ($.type(args[0]) === "object") {
+ oMuligrid = args[0];
+ } else {
+ if (keys !== undefined) { oMuligrid.keys = keys; }
+ if ($.isFunction(oneditfunc)) { oMuligrid.oneditfunc = oneditfunc; }
+ if ($.isFunction(successfunc)) { oMuligrid.successfunc = successfunc; }
+ if (url !== undefined) { oMuligrid.url = url; }
+ if (extraparam != null) { oMuligrid.extraparam = extraparam; }
+ if ($.isFunction(aftersavefunc)) { oMuligrid.aftersavefunc = aftersavefunc; }
+ if ($.isFunction(errorfunc)) { oMuligrid.errorfunc = errorfunc; }
+ if ($.isFunction(afterrestorefunc)) { oMuligrid.afterrestorefunc = afterrestorefunc; }
+ if ($.isFunction(beforeEditRow)) { oMuligrid.beforeEditRow = beforeEditRow; }
+ // last two not as param, but as object (sorry)
+ //if (restoreAfterError !== undefined) { oMuligrid.restoreAfterError = restoreAfterError; }
+ //if (mtype !== undefined) { oMuligrid.mtype = mtype || "POST"; }
+ }
+
+ // End compatible
+ return this.each(function () {
+ var $t = this, $self = $($t), p = $t.p, cnt = 0, focus = null, svr = {}, editableValues = {}, colModel = p.colModel, opers = p.prmNames;
+ if (!$t.grid) { return; }
+ var o = $.extend(true, {
+ keys: false,
+ oneditfunc: null,
+ successfunc: null,
+ url: null,
+ extraparam: {},
+ aftersavefunc: null,
+ errorfunc: null,
+ afterrestorefunc: null,
+ restoreAfterError: true,
+ beforeEditRow: null,
+ //mtype: "POST",
+ focusField: true
+ }, jgrid.inlineEdit, p.inlineEditing || {}, oMuligrid),
+ ind = $self.jqGrid("getInd", rowid, true),
+ focusField = o.focusField,
+ td = typeof focusField === "object" && focusField != null ?
+ $(focusField.target || focusField).closest("tr.jqgrow>td")[0] : null;
+
+ if (ind === false) { return; }
+
+ if (o.extraparam[opers.oper] !== opers.addoper) {
+ if (!editFeedback.call($t, o, "beforeEditRow", o, rowid)) { return; }
+ }
+
+ if (($(ind).attr("editable") || "0") === "0" && !$(ind).hasClass("not-editable-row")) {
+ var editingInfo = jgrid.detectRowEditing.call($t, rowid);
+ if (editingInfo != null && editingInfo.mode === "cellEditing") {
+ var savedRowInfo = editingInfo.savedRow, tr = $t.rows[savedRowInfo.id],
+ highlightClass = getGuiStateStyles.call($t, "select");
+ $self.jqGrid("restoreCell", savedRowInfo.id, savedRowInfo.ic);
+ // remove highlighting of the cell
+ $(tr.cells[savedRowInfo.ic]).removeClass("edit-cell " + highlightClass);
+ $(tr).addClass(highlightClass).attr({ "aria-selected": "true", "tabindex": "0" });
+ }
+ jgrid.enumEditableCells.call($t, ind, $(ind).hasClass("jqgrid-new-row") ? "add" : "edit", function (options) {
+ var cm = options.cm, $dataFiled = $(options.dataElement), dataWidth = options.dataWidth, tmp, opt, elc,
+ nm = cm.name, edittype = cm.edittype, iCol = options.iCol, editoptions = cm.editoptions || {};
+ editableValues[nm] = options.editable;
+ if (options.editable === "hidden") { return; }
+ try {
+ tmp = $.unformat.call(this, options.td, { rowId: rowid, colModel: cm }, iCol);
+ } catch (_) {
+ tmp = edittype === "textarea" ? $dataFiled.text() : $dataFiled.html();
+ }
+ svr[nm] = tmp; // include only editable fields in svr object
+ $dataFiled.html("");
+ opt = $.extend({}, editoptions,
+ { id: rowid + "_" + nm, name: nm, rowId: rowid, mode: options.mode, cm: cm, iCol: iCol });
+ if (tmp === " " || tmp === " " || (tmp.length === 1 && tmp.charCodeAt(0) === 160)) { tmp = ""; }
+ elc = jgrid.createEl.call($t, edittype, opt, tmp, true, $.extend({}, jgrid.ajaxOptions, p.ajaxSelectOptions || {}));
+ $(elc).addClass("editable");
+ $dataFiled.append(elc);
+ if (dataWidth) {
+ // change the width from auto or the value from editoptions
+ // in case of editing ExpandColumn of TreeGrid
+ $(elc).width(options.dataWidth);
+ }
+ jgrid.bindEv.call($t, elc, opt);
+ //Again IE
+ if (edittype === "select" && editoptions.multiple === true && editoptions.dataUrl === undefined && jgrid.msie) {
+ $(elc).width($(elc).width());
+ }
+ if (focus === null) { focus = iCol; }
+ cnt++;
+ });
+ if (cnt > 0) {
+ svr.id = rowid;
+ p.savedRow.push(svr);
+ p.editingInfo[rowid] = {
+ mode: "inlineEditing",
+ savedRow: svr,
+ editable: editableValues
+ };
+ $(ind).attr("editable", "1");
+ if (focusField) {
+ if (typeof focusField === "number" && parseInt(focusField, 10) <= colModel.length) {
+ focus = focusField;
+ } else if (typeof focusField === "string") {
+ focus = p.iColByName[focusField];
+ } else if (td != null) {
+ focus = td.cellIndex;
+ }
+ setTimeout(function () {
+ // we want to use ":focusable"
+ var nFrozenColumns = $self.jqGrid("getNumberOfFrozenColumns"),
+ getTdByColIndex = function (iCol) {
+ return p.frozenColumns && nFrozenColumns > 0 && focus < nFrozenColumns ?
+ $t.grid.fbRows[ind.rowIndex].cells[iCol] :
+ ind.cells[iCol];
+ },
+ getFocusable = function (elem) {
+ return $(elem).find("input,textarea,select,button,object,*[tabindex]")
+ .filter(":input:visible:not(:disabled)");
+ },
+ getFirstFocusable = function () {
+ return getFocusable(p.frozenColumns && nFrozenColumns > 0 ? $t.grid.fbRows[ind.rowIndex] : ind)
+ .first();
+ },
+ $fe = getFocusable(getTdByColIndex(focus));
+
+ if ($fe.length > 0) {
+ $fe.first().focus();
+ } else if (typeof o.defaultFocusField === "number" || typeof o.defaultFocusField === "string") {
+ $fe = getFocusable(getTdByColIndex(typeof o.defaultFocusField === "number" ? o.defaultFocusField : p.iColByName[o.defaultFocusField]));
+ if ($fe.length === 0) {
+ $fe = getFirstFocusable();
+ }
+ $fe.first().focus();
+ } else {
+ getFirstFocusable().focus();
+ }
+ }, 0);
+ }
+ if (o.keys === true) {
+ var $ind = $(ind);
+ if (p.frozenColumns) {
+ $ind = $ind.add($t.grid.fbRows[ind.rowIndex]);
+ }
+ $ind.on("keydown", function (e) {
+ if (e.keyCode === 27) {
+ $self.jqGrid("restoreRow", rowid, o.afterrestorefunc);
+ return false;
+ }
+ if (e.keyCode === 13) {
+ var ta = e.target;
+ if (ta.tagName === "TEXTAREA") { return true; }
+ $self.jqGrid("saveRow", rowid, o);
+ return false;
+ }
+ });
+ }
+ fullBoolFeedback.call($t, o.oneditfunc, "jqGridInlineEditRow", rowid, o);
+ }
+ }
+ });
+ },
+ saveRow: function (rowid, successfunc, url, extraparam, aftersavefunc, errorfunc, afterrestorefunc, beforeSaveRow) {
+ // Compatible mode old versions
+ var args = $.makeArray(arguments).slice(1), o = {}, $t = this[0], $self = $($t),
+ p = $t != null ? $t.p : null, editOrAdd, infoDialog = jgrid.info_dialog,
+ isFunction = $.isFunction,
+ fatalErrorFunction = jgrid.defaults != null && isFunction(jgrid.defaults.fatalError) ? jgrid.defaults.fatalError : alert;
+ if (!$t.grid || p == null) { return; }
+
+ if ($.type(args[0]) === "object") {
+ o = args[0];
+ } else {
+ if (isFunction(successfunc)) { o.successfunc = successfunc; }
+ if (url !== undefined) { o.url = url; }
+ if (extraparam !== undefined) { o.extraparam = extraparam; }
+ if (isFunction(aftersavefunc)) { o.aftersavefunc = aftersavefunc; }
+ if (isFunction(errorfunc)) { o.errorfunc = errorfunc; }
+ if (isFunction(afterrestorefunc)) { o.afterrestorefunc = afterrestorefunc; }
+ if (isFunction(beforeSaveRow)) { o.beforeSaveRow = beforeSaveRow; }
+ }
+ var getRes = function (path) { return $self.jqGrid("getGridRes", path); };
+ o = $.extend(true, {
+ successfunc: null,
+ url: null,
+ extraparam: {},
+ aftersavefunc: null,
+ errorfunc: null,
+ afterrestorefunc: null,
+ restoreAfterError: true,
+ beforeSaveRow: null,
+ ajaxSaveOptions: {},
+ serializeSaveData: null,
+ mtype: "POST",
+ saveui: "enable",
+ savetext: getRes("defaults.savetext") || "Saving..."
+ }, jgrid.inlineEdit, p.inlineEditing || {}, o);
+ // End compatible
+ // TODO: add return this.each(function(){....}
+ var tmp = {}, tmp2 = {}, postData = {}, editable, k, fr, resp, cv, editingInfo, ind = $self.jqGrid("getInd", rowid, true), $tr = $(ind),
+ opers = p.prmNames, errcap = getRes("errors.errcap"), bClose = getRes("edit.bClose"), isRemoteSave, isError,
+ displayErrorMessage = function (text, relativeElem) {
+ try {
+ var relativeRect = jgrid.getRelativeRect.call($t, relativeElem);
+
+ infoDialog.call($t, errcap, text, bClose, {
+ top: relativeRect.top,
+ left: relativeRect.left + $($t).closest(".ui-jqgrid").offset().left
+ });
+ } catch (e) {
+ fatalErrorFunction(text);
+ }
+ };
+
+ if (ind === false) { return; }
+
+ editOrAdd = o.extraparam[opers.oper] === opers.addoper ? "add" : "edit";
+
+ if (!editFeedback.call($t, o, "beforeSaveRow", o, rowid, editOrAdd)) { return; }
+
+ editable = $tr.attr("editable");
+ o.url = o.url || p.editurl;
+ isRemoteSave = o.url !== "clientArray";
+ if (editable === "1") {
+ editingInfo = $.jgrid.detectRowEditing.call($t, rowid);
+ jgrid.enumEditableCells.call($t, ind, $tr.hasClass("jqgrid-new-row") ? "add" : "edit", function (options) {
+ var cm = options.cm, formatter = cm.formatter, editoptions = cm.editoptions || {},
+ formatoptions = cm.formatoptions || {}, valueText = {},
+ v = jgrid.getEditedValue.call($t, $(options.dataElement), cm, valueText, options.editable);
+
+ if (cm.edittype === "select" && cm.formatter !== "select") {
+ tmp2[cm.name] = valueText.text;
+ }
+ cv = jgrid.checkValues.call($t, v, options.iCol, undefined, undefined,
+ $.extend(options, {
+ oldValue: editingInfo != null ? editingInfo.savedRow[cm.name] : null,
+ newValue: v,
+ oldRowData: editingInfo != null ? editingInfo.savedRow : null }));
+ if (cv != null && cv[0] === false) {
+ isError = true;
+ displayErrorMessage(cv[1], options.td);
+ return false;
+ }
+ if (formatter === "date" && formatoptions.sendFormatted !== true) {
+ // TODO: call all other predefined formatters!!! Not only formatter: "date" have the problem.
+ // Floating point separator for example
+ v = $.unformat.date.call($t, v, cm);
+ }
+ if (isRemoteSave && editoptions.NullIfEmpty === true) {
+ if (v === "") {
+ v = "null";
+ }
+ }
+ tmp[cm.name] = v;
+ });
+
+ if (isError) {
+ return;
+ }
+ var idname;
+ opers = p.prmNames;
+ if (p.keyName === false) {
+ idname = opers.id;
+ } else {
+ idname = p.keyName;
+ }
+ if (tmp) {
+ tmp[opers.oper] = opers.editoper;
+ if (tmp[idname] === undefined || tmp[idname] === "") {
+ tmp[idname] = jgrid.stripPref(p.idPrefix, rowid);
+ }
+ tmp = $.extend({}, tmp, p.inlineData || {}, o.extraparam);
+ }
+ var validationOptions = {
+ options: o,
+ rowid: rowid,
+ tr: ind,
+ iRow: ind.rowIndex,
+ savedRow: editingInfo.savedRow,
+ newData: tmp,
+ mode: editOrAdd
+ };
+ if (!editFeedback.call($t, o, "saveRowValidation", validationOptions)) {
+ if (validationOptions.errorText) {
+ displayErrorMessage(validationOptions.errorText, ind);
+ }
+ return;
+ }
+ if (!isRemoteSave) {
+ tmp = $.extend({}, tmp, tmp2);
+ resp = $self.jqGrid("setRowData", rowid, tmp);
+ $tr.attr("editable", "0");
+ for (k = 0; k < p.savedRow.length; k++) {
+ if (String(p.savedRow[k].id) === String(rowid)) { fr = k; break; }
+ }
+ if (fr >= 0) {
+ p.savedRow.splice(fr, 1);
+ delete p.editingInfo[rowid];
+ }
+ fullBoolFeedback.call($t, o.aftersavefunc, "jqGridInlineAfterSaveRow", rowid, resp, tmp, o);
+ $tr.removeClass("jqgrid-new-row").off("keydown");
+ if (ind.id !== p.idPrefix + tmp[idname]) {
+ $self.jqGrid("changeRowid", ind.id, p.idPrefix + tmp[idname]);
+ }
+ } else {
+ $self.jqGrid("progressBar", { method: "show", loadtype: o.saveui, htmlcontent: o.savetext });
+ postData = $.extend({}, tmp, postData);
+ postData[idname] = jgrid.stripPref(p.idPrefix, postData[idname]);
+ if (p.autoEncodeOnEdit) {
+ $.each(postData, function (n, v) {
+ if (!isFunction(v)) {
+ postData[n] = jgrid.oldEncodePostedData(v);
+ }
+ });
+ }
+ if (ind.id !== p.idPrefix + postData[idname] && opers.idold != null &&
+ !postData.hasOwnProperty(opers.idold)) {
+ postData[opers.idold] = jgrid.stripPref(p.idPrefix, ind.id);
+ }
+
+ $.ajax($.extend({
+ url: isFunction(o.url) ? o.url.call($t, postData[idname], editOrAdd, postData, o) : o.url,
+ data: jgrid.serializeFeedback.call($t,
+ isFunction(o.serializeSaveData) ? o.serializeSaveData : p.serializeRowData,
+ "jqGridInlineSerializeSaveData",
+ postData),
+ type: isFunction(o.mtype) ? o.mtype.call($t, editOrAdd, o, postData[idname], postData) : o.mtype,
+ complete: function (jqXHR, textStatus) {
+ $self.jqGrid("progressBar", { method: "hide", loadtype: o.saveui });
+ // textStatus can be "abort", "timeout", "error", "parsererror" or some text from text part of HTTP error occurs
+ // see the answer http://stackoverflow.com/a/3617710/315935 about xhr.readyState === 4 && xhr.status === 0
+ if ((jqXHR.status < 300 || jqXHR.status === 304) && (jqXHR.status !== 0 || jqXHR.readyState !== 4)) {
+ var ret, sucret, j;
+ sucret = $self.triggerHandler("jqGridInlineSuccessSaveRow", [jqXHR, rowid, o, editOrAdd, postData]);
+ if (sucret == null || sucret === true) { sucret = [true, tmp]; }
+ if (sucret[0] && isFunction(o.successfunc)) { sucret = o.successfunc.call($t, jqXHR, rowid, o, editOrAdd, postData); }
+ if ($.isArray(sucret)) {
+ // expect array - status, data, rowid
+ ret = sucret[0];
+ tmp = sucret[1] || tmp;
+ } else {
+ ret = sucret;
+ }
+ if (ret === true) {
+ if (p.autoEncodeOnEdit) {
+ $.each(tmp, function (n, v) {
+ tmp[n] = jgrid.oldDecodePostedData(v);
+ });
+ }
+ tmp = $.extend({}, tmp, tmp2);
+ $self.jqGrid("setRowData", rowid, tmp);
+ $tr.attr("editable", "0");
+ for (j = 0; j < p.savedRow.length; j++) {
+ if (String(p.savedRow[j].id) === String(rowid)) { fr = j; break; }
+ }
+ if (fr >= 0) {
+ p.savedRow.splice(fr, 1);
+ delete p.editingInfo[rowid];
+ }
+ fullBoolFeedback.call($t, o.aftersavefunc, "jqGridInlineAfterSaveRow", rowid, jqXHR, tmp, o);
+ if (sucret[2] != null) {
+ $self.jqGrid("changeRowid", rowid, p.idPrefix + sucret[2]);
+ } else if (ind.id !== p.idPrefix + tmp[idname]) {
+ $self.jqGrid("changeRowid", ind.id, p.idPrefix + tmp[idname]);
+ }
+ $tr.removeClass("jqgrid-new-row").off("keydown");
+ } else {
+ fullBoolFeedback.call($t, o.errorfunc, "jqGridInlineErrorSaveRow", rowid, jqXHR, textStatus, null, o);
+ if (o.restoreAfterError === true) {
+ $self.jqGrid("restoreRow", rowid, o.afterrestorefunc);
+ }
+ }
+ }
+ },
+ error: function (res, stat, err) {
+ $self.triggerHandler("jqGridInlineErrorSaveRow", [rowid, res, stat, err, o]);
+ if (isFunction(o.errorfunc)) {
+ o.errorfunc.call($t, rowid, res, stat, err);
+ } else {
+ var rT = res.responseText || res.statusText;
+ try {
+ infoDialog.call($t, errcap, '' + rT + "
", bClose, { buttonalign: "right" });
+ } catch (e1) {
+ fatalErrorFunction(rT);
+ }
+ }
+ if (o.restoreAfterError === true) {
+ $self.jqGrid("restoreRow", rowid, o.afterrestorefunc);
+ }
+ }
+ }, jgrid.ajaxOptions, p.ajaxRowOptions, o.ajaxSaveOptions || {}));
+ }
+ }
+ return;
+ },
+ restoreRow: function (rowid, afterrestorefunc) {
+ // Compatible mode old versions
+ var args = $.makeArray(arguments).slice(1), oMuligrid = {};
+
+ if ($.type(args[0]) === "object") {
+ oMuligrid = args[0];
+ } else {
+ if ($.isFunction(afterrestorefunc)) { oMuligrid.afterrestorefunc = afterrestorefunc; }
+ }
+
+ // End compatible
+
+ return this.each(function () {
+ var $t = this, $self = $($t), p = $t.p, fr = -1, ares = {}, k;
+ if (!$t.grid) { return; }
+
+ var o = $.extend(true, {}, jgrid.inlineEdit, p.inlineEditing || {}, oMuligrid);
+ var ind = $self.jqGrid("getInd", rowid, true);
+ if (ind === false) { return; }
+
+ if (!editFeedback.call($t, o, "beforeCancelRow", o, rowid)) { return; }
+
+ for (k = 0; k < p.savedRow.length; k++) {
+ if (String(p.savedRow[k].id) === String(rowid)) {
+ fr = k;
+ break;
+ }
+ }
+ if (fr >= 0) {
+ if ($.isFunction($.fn.datepicker)) {
+ try {
+ $("input.hasDatepicker", "#" + jgrid.jqID(ind.id)).datepicker("hide");
+ } catch (ignore) { }
+ }
+
+ $.each(p.colModel, function () {
+ var nm = this.name;
+ if (p.savedRow[fr].hasOwnProperty(nm)) {
+ ares[nm] = p.savedRow[fr][nm];
+ if (this.formatter && this.formatter === "date" && (this.formatoptions == null || this.formatoptions.sendFormatted !== true)) {
+ // TODO: call all other predefined formatters!!! Not only formatter: "date" have the problem.
+ // Floating point separator for example
+ ares[nm] = $.unformat.date.call($t, ares[nm], this);
+ }
+ }
+ });
+ $self.jqGrid("setRowData", rowid, ares);
+ $(ind).attr("editable", "0").off("keydown");
+ p.savedRow.splice(fr, 1);
+ delete p.editingInfo[rowid];
+ if ($("#" + jgrid.jqID(rowid), $t).hasClass("jqgrid-new-row")) {
+ setTimeout(function () {
+ $self.jqGrid("delRowData", rowid);
+ $self.jqGrid("showAddEditButtons", false);
+ }, 0);
+ }
+ }
+ fullBoolFeedback.call($t, o.afterrestorefunc, "jqGridInlineAfterRestoreRow", rowid);
+ });
+ },
+ addRow: function (oMuligrid) {
+ return this.each(function () {
+ if (!this.grid) { return; }
+
+ var $t = this, $self = $($t), p = $t.p,
+ o = $.extend(true, {
+ rowID: null,
+ initdata: {},
+ position: "first",
+ useDefValues: true,
+ useFormatter: false,
+ beforeAddRow: null,
+ addRowParams: { extraparam: {} }
+ }, jgrid.inlineEdit, p.inlineEditing || {}, oMuligrid || {});
+ if (!editFeedback.call($t, o, "beforeAddRow", o.addRowParams)) { return; }
+
+ o.rowID = $.isFunction(o.rowID) ? o.rowID.call($t, o) : ((o.rowID != null) ? o.rowID : jgrid.randId());
+ if (o.useDefValues === true) {
+ $(p.colModel).each(function () {
+ if (this.editoptions && this.editoptions.defaultValue) {
+ var opt = this.editoptions.defaultValue;
+ o.initdata[this.name] = $.isFunction(opt) ? opt.call($t, o) : opt;
+ }
+ });
+ }
+ o.rowID = p.idPrefix + o.rowID;
+ $self.jqGrid("addRowData", o.rowID, o.initdata, o.position);
+ $("#" + jgrid.jqID(o.rowID), $t).addClass("jqgrid-new-row");
+ if (o.useFormatter) {
+ $("#" + jgrid.jqID(o.rowID) + " .ui-inline-edit", $t).click();
+ } else {
+ var opers = p.prmNames, oper = opers.oper;
+ o.addRowParams.extraparam[oper] = opers.addoper;
+ $self.jqGrid("editRow", o.rowID, o.addRowParams);
+ $self.jqGrid("setSelection", o.rowID);
+ }
+ });
+ },
+ inlineNav: function (elem, oMuligrid) {
+ if (typeof elem === "object") {
+ // the option pager are skipped
+ oMuligrid = elem;
+ elem = undefined;
+ }
+ return this.each(function () {
+ var $t = this, $self = $($t), p = $t.p;
+ if (!this.grid || p == null) { return; }
+ var $elem, gID = elem === p.toppager ? p.idSel + "_top" : p.idSel,
+ gid = elem === p.toppager ? p.id + "_top" : p.id, disabledClass = getGuiStateStyles.call($t, "disabled"),
+ o = $.extend(true,
+ {
+ edit: true,
+ editicon: "ui-icon-pencil",
+ add: true,
+ addicon: "ui-icon-plus",
+ save: true,
+ saveicon: "ui-icon-disk",
+ cancel: true,
+ cancelicon: "ui-icon-cancel",
+ commonIconClass: "ui-icon",
+ iconsOverText: false,
+ //alertToTop: false, use undefined to be able to use defaults from $.jgrid.jqModal or later from p.jqModal
+ addParams: { addRowParams: { extraparam: {} } },
+ editParams: {},
+ restoreAfterSelect: true
+ },
+ //TODO make getRes(locales[p.locale], "nav"), jgrid.nav || {}, p.navOptions || {}
+ // as the result of working getRes("nav")
+ //getRes(locales[p.locale], "nav"),
+ $self.jqGrid("getGridRes", "nav"),
+ jgrid.nav || {},
+ p.navOptions || {},
+ jgrid.inlineNav || {},
+ p.inlineNavOptions || {},
+ oMuligrid || {}
+ ),
+ viewModalAlert = function () {
+ $t.modalAlert();
+ };
+
+ if (elem === undefined) {
+ if (p.pager) {
+ $self.jqGrid("inlineNav", p.pager, o);
+ if (p.toppager) {
+ elem = p.toppager;
+ gID = p.idSel + "_top";
+ gid = p.id + "_top";
+ } else {
+ return;
+ }
+ } else if (p.toppager) {
+ elem = p.toppager;
+ gID = p.idSel + "_top";
+ gid = p.id + "_top";
+ }
+ }
+ if (elem === undefined) {
+ return; // error
+ }
+ $elem = $(elem);
+ if ($elem.length <= 0) {
+ return; // error
+ }
+ if ($elem.find(".navtable").length <= 0) {
+ // create navigator bar if it is not yet exist
+ $self.jqGrid("navGrid", elem, { add: false, edit: false, del: false, search: false, refresh: false, view: false });
+ }
+
+ p._inlinenav = true;
+ // detect the formatactions column
+ if (o.addParams.useFormatter === true) {
+ var cm = p.colModel, i, defaults, ap;
+ for (i = 0; i < cm.length; i++) {
+ if (cm[i].formatter && cm[i].formatter === "actions") {
+ if (cm[i].formatoptions) {
+ defaults = {
+ keys: false,
+ onEdit: null,
+ onSuccess: null,
+ afterSave: null,
+ onError: null,
+ afterRestore: null,
+ extraparam: {},
+ url: null
+ };
+ ap = $.extend(defaults, cm[i].formatoptions);
+ o.addParams.addRowParams = {
+ "keys": ap.keys,
+ "oneditfunc": ap.onEdit,
+ "successfunc": ap.onSuccess,
+ "url": ap.url,
+ "extraparam": ap.extraparam,
+ "aftersavefunc": ap.afterSave,
+ "errorfunc": ap.onError,
+ "afterrestorefunc": ap.afterRestore
+ };
+ }
+ break;
+ }
+ }
+ }
+ if (o.add) {
+ $self.jqGrid("navButtonAdd", elem, {
+ caption: o.addtext,
+ title: o.addtitle,
+ commonIconClass: o.commonIconClass,
+ buttonicon: o.addicon,
+ iconsOverText: o.iconsOverText,
+ id: gid + "_iladd",
+ onClickButton: function () {
+ if (!hasOneFromClasses(this, disabledClass)) {
+ $self.jqGrid("addRow", o.addParams);
+ }
+ }
+ });
+ }
+ if (o.edit) {
+ $self.jqGrid("navButtonAdd", elem, {
+ caption: o.edittext,
+ title: o.edittitle,
+ commonIconClass: o.commonIconClass,
+ buttonicon: o.editicon,
+ iconsOverText: o.iconsOverText,
+ id: gid + "_iledit",
+ onClickButton: function () {
+ if (!hasOneFromClasses(this, disabledClass)) {
+ var sr = p.selrow;
+ if (sr) {
+ $self.jqGrid("editRow", sr, o.editParams);
+ } else {
+ viewModalAlert();
+ }
+ }
+ }
+ });
+ }
+ if (o.save) {
+ $self.jqGrid("navButtonAdd", elem, {
+ caption: o.savetext,
+ title: o.savetitle,
+ commonIconClass: o.commonIconClass,
+ buttonicon: o.saveicon,
+ iconsOverText: o.iconsOverText,
+ id: gid + "_ilsave",
+ onClickButton: function () {
+ if (!hasOneFromClasses(this, disabledClass)) {
+ var sr = p.savedRow[0].id;
+ if (sr) {
+ var opers = p.prmNames, oper = opers.oper, tmpParams = o.editParams;
+ if ($("#" + jgrid.jqID(sr), $t).hasClass("jqgrid-new-row")) {
+ o.addParams.addRowParams.extraparam[oper] = opers.addoper;
+ tmpParams = o.addParams.addRowParams;
+ } else {
+ if (!o.editParams.extraparam) {
+ o.editParams.extraparam = {};
+ }
+ o.editParams.extraparam[oper] = opers.editoper;
+ }
+ $self.jqGrid("saveRow", sr, tmpParams);
+ } else {
+ viewModalAlert();
+ }
+ }
+ }
+ });
+ $(gID + "_ilsave").addClass(disabledClass);
+ }
+ if (o.cancel) {
+ $self.jqGrid("navButtonAdd", elem, {
+ caption: o.canceltext,
+ title: o.canceltitle,
+ commonIconClass: o.commonIconClass,
+ buttonicon: o.cancelicon,
+ iconsOverText: o.iconsOverText,
+ id: gid + "_ilcancel",
+ onClickButton: function () {
+ if (!hasOneFromClasses(this, disabledClass)) {
+ var sr = p.savedRow[0].id, cancelPrm = o.editParams;
+ if (sr) {
+ if ($("#" + jgrid.jqID(sr), $t).hasClass("jqgrid-new-row")) {
+ cancelPrm = o.addParams.addRowParams;
+ }
+ $self.jqGrid("restoreRow", sr, cancelPrm);
+ } else {
+ viewModalAlert();
+ }
+ }
+ }
+ });
+ $(gID + "_ilcancel").addClass(disabledClass);
+ }
+ if (o.restoreAfterSelect === true) {
+ $self.on("jqGridSelectRow", function (e, rowid) {
+ if (p.savedRow.length > 0 && p._inlinenav === true) {
+ var editingRowId = p.savedRow[0].id;
+ if (rowid !== editingRowId && typeof editingRowId !== "number") {
+ $self.jqGrid("restoreRow", editingRowId, o.editParams);
+ }
+ }
+ });
+ }
+ $self.on("jqGridInlineAfterRestoreRow jqGridInlineAfterSaveRow", function () {
+ $self.jqGrid("showAddEditButtons", false);
+ });
+ $self.on("jqGridInlineEditRow", function (e, rowid) {
+ $self.jqGrid("showAddEditButtons", true, rowid);
+ });
+ });
+ },
+ showAddEditButtons: function (isEditing) {
+ return this.each(function () {
+ var $t = this;
+ if (!$t.grid) { return; }
+ var p = $t.p, idSel = p.idSel, disabledClass = getGuiStateStyles.call($t, "disabled"),
+ saveCancel = idSel + "_ilsave," + idSel + "_ilcancel" + (p.toppager ? "," + idSel + "_top_ilsave," + idSel + "_top_ilcancel" : ""),
+ addEdit = idSel + "_iladd," + idSel + "_iledit" + (p.toppager ? "," + idSel + "_top_iladd," + idSel + "_top_iledit" : "");
+ $(isEditing ? addEdit : saveCancel).addClass(disabledClass);
+ $(isEditing ? saveCancel : addEdit).removeClass(disabledClass);
+ });
+ }
+ });
+ // end module grid.inlinedit
+
+ /**
+ * jqGrid addons using jQuery UI
+ * Author: Mark Williams
+ * Changed by Oleg Kiriljuk, oleg.kiriljuk@ok-soft-gmbh.com
+ * Dual licensed under the MIT and GPL licenses:
+ * http://www.opensource.org/licenses/mit-license.php
+ * http://www.gnu.org/licenses/gpl-2.0.html
+ * depends on jQuery UI
+ **/
+ // begin module grid.jqueryui
+ var $UiMultiselect = $.ui != null ? $.ui.multiselect : null,
+ reorderSelectedColumns = function (iColItem) {
+ /* Background information:
+ *
+ * Multiselect contains the list of selected items this.selectedList,
+ * which is jQuery wrapper of element. The items of this.selectedList
+ * are elements, which represent visible (hidden:false) and movable
+ * (hidedlg:false) columns of the grid.
+ *
+ * Additionally there are exist hidden .
+ * Every of the corresponds the column of the grid.
+ * The visible columns (hidden:false) are selected. The value of the
+ * contains the column index (iCol) in colModel. elements of
+ * this.selectedLis have data with the "optionLink" pointed to the corresponding
+ * option of the hidden select.
+ *
+ * this.grid is the DOM of the grid and this.newColOrder is the array with
+ * ALL column names in the order, which should be applied after reordering
+ * the grid. Additionally this.gh contains the COPY of p.groupHeader.groupHeaders.
+ * It's important that startColumnName property of elements of
+ * p.groupHeader.groupHeaders could be changed during reordering of the columns.
+ * On the other side the user can't click Cancel button of columnChooser for
+ * breaking reordering. Because of that this.gh contains the COPY of
+ * p.groupHeader.groupHeaders and the original p.groupHeader.groupHeaders will be
+ * not changed in the reorderSelectedColumns function.
+ *
+ * An important implementation problem: reorderSelectedColumns function will be
+ * called after ONE reordering of the columns. On the other side, the user can
+ * reorder the columns MULTIPLE TIMES before saving the new order. Thus, one
+ * have to take in consideration not only the original order of columns in
+ * colModel, but THE CURRENT order of the columns saved only internally in
+ * the dialog in this.newColOrder.
+ */
+ if (this.grid != null && this.grid.p != null) {
+ var that = this, p = this.grid.p, iCol, j, iGrp, ghItem,
+ gh = this.gh, selectedList = this.selectedList, inGroup = this.inGroup,
+ items = selectedList.find("li"), optionLink,
+ indexOfAddedItem = items.length - 1,
+ enumSelected = function (callback, startIndex, reverse) {
+ var i, opt, items = selectedList.find("li");
+ if (startIndex === undefined) {
+ startIndex = reverse ? items.length - 1 : 0;
+ }
+ for (i = startIndex; !reverse ? i < items.length : i >= 0; !reverse ? i++ : i--) {
+ opt = $(items[i]).data("optionLink");
+ if (opt && callback.call(items[i], parseInt(opt.val(), 10), i)) {
+ return i;
+ }
+ }
+ },
+ updateNewColOrder = function () {
+ // !!! the function set additionally indexOfAddedItem and update items
+
+ // remove iColItem from this.newColOrder
+ j = $.inArray(p.colModel[iColItem].name, that.newColOrder);
+ if (j >= 0) {
+ that.newColOrder.splice(j, 1);
+ }
+
+ // refill items
+ items = selectedList.find("li");
+
+ // iCol will be the index in newColOrder. The order of columns in items
+ // should be mostly THE SAME like in selectedList, but newColOrder
+ // contains additional elements (hidden and hidedlg). The array items
+ // on the other side contains just inserted iColItem element.
+
+ // we need find indexOfAddedItem - the index of with iColItem
+ // in the list of this.selectedList.find("li") elements
+ iCol = 0;
+ enumSelected(
+ function (iColOld, index) {
+ if (iColOld === iColItem) {
+ indexOfAddedItem = index;
+ // if iColItem is in the same header group as p.colModel[iCol] or
+ // both belongs no header group then the column could be NOT in
+ // selectedList. I find better to insert the item AFTER the hidden
+ // or non-movable columns (like "rn", "subgrid" column or other)
+ while (iCol >= 0 && iCol < p.colModel.length &&
+ (p.colModel[iCol].hidden || p.colModel[iCol].hidedlg) &&
+ inGroup != null &&
+ //inGroup[iCol] !== undefined && inGroup[iColItem] !== undefined &&
+ inGroup[iCol] === inGroup[iColItem]) {
+ iCol++;
+ }
+ that.newColOrder.splice(iCol, 0, p.colModel[iColItem].name);
+ return true; // stop enumeration
+ }
+ // selectedList contains SUBSET of columns from colModel, but newColOrder
+ // contains ALL columns. It's important that all columns from selectedList
+ // exist in newColOrder IN THE SAME order. Thus iCol will be the current
+ // index in newColOrder array with p.colModel[iColOld].name column name.
+ iCol = $.inArray(p.colModel[iColOld].name, that.newColOrder, iCol);
+ if (iCol < 0) {
+ // to be sure that the code works in case of some errors too
+ iCol = $.inArray(p.colModel[iColOld].name, that.newColOrder);
+ }
+ iCol++;
+ }
+ );
+ },
+ enumPreviousAndInsertAfter = function (iCol) {
+ if (inGroup[iCol] === inGroup[iColItem]) {
+ $(this).after(items[indexOfAddedItem]);
+ updateNewColOrder();
+ return true; // stop enumeration
+ }
+ },
+ enumNextAndInsertBefore = function (iCol) {
+ if (inGroup[iCol] === inGroup[iColItem]) {
+ $(this).before(items[indexOfAddedItem]);
+ updateNewColOrder();
+ return true; // stop enumeration
+ }
+ },
+ updateStartColumn = function (iCol) {
+ if (inGroup[iCol] === inGroup[iColItem] && inGroup[iCol] !== undefined) {
+ gh[inGroup[iCol]].startColumnName = p.colModel[iCol].name;
+ return true; // stop enumeration
+ }
+ };
+
+ // Fix potition of added/moved item iColItem in that.newColOrder array.
+ // We syncronize only the initial state of newColOrder. The position of
+ // iColItem item can be changed later in both selectedList and newColOrder
+ updateNewColOrder();
+
+ if (gh && gh[inGroup[iColItem]] !== undefined) {
+ // the item belong to some group
+ ghItem = gh[inGroup[iColItem]];
+ for (j = 0; j < ghItem.numberOfColumns; j++) {
+ iCol = p.iColByName[ghItem.startColumnName] + j;
+ if (!p.colModel[iCol].hidden && !p.colModel[iCol].hidedlg) {
+ // the columns are displayed in the selectedList
+
+ // We need to enumerate items in reverse order and to find the index of the item
+ // in the array items comparing the items by $(items[j]).data("optionLink").val()
+ // If the item is found then append prevously found item AFTER this one.
+ // We can use j variable bacause the outer loop will be exit (see break below)
+ enumSelected(
+ enumPreviousAndInsertAfter,
+ indexOfAddedItem - 1,
+ true // enum in reverse order
+ );
+ // If step 2 didn't find the group then we need examin NEXT items and find
+ // the items from the same group. We should test the items in sequential order
+ // after the item found. If the item is found then apend prevously found
+ // item BEFORE this one.
+ enumSelected(
+ enumNextAndInsertBefore,
+ indexOfAddedItem + 1
+ );
+ // fix the name of the first column in the group
+ enumSelected(updateStartColumn);
+ break; // !!!
+ }
+ }
+ } else if (gh) {
+ // The item from no group is added/moved.
+ // We have to verify that the item is not dropped inside of some header group
+ // find the index of added/moved element in this.selectedList.find("li")
+ items = selectedList.find("li");
+ j = enumSelected(function (iCol) {
+ if (iCol === iColItem) {
+ return true;
+ }
+ });
+ if (j + 1 >= items.length || j < 0) {
+ return;
+ }
+ optionLink = $(items[j + 1]).data("optionLink");
+ if (optionLink) {
+ iGrp = inGroup[parseInt(optionLink.val(), 10)];
+ if (iGrp !== undefined) {
+ optionLink = $(items[j - 1]).data("optionLink");
+ if (optionLink && inGroup[parseInt(optionLink.val(), 10)] === iGrp) {
+ // The next and the previous items are in the same group, but
+ // the added/moved item in NOT in the group.
+ // We have to move the item items[j] AFTER the last item of the group.
+ var iColNotInTheGroup = enumSelected(
+ function (iCol) {
+ if (inGroup[iCol] !== iGrp) {
+ return true; // stop enumeration
+ }
+ },
+ j + 1 // start enumeration with the index
+ );
+ $(items[iColNotInTheGroup === undefined || iColNotInTheGroup >= items.length ? items.length - 1 : iColNotInTheGroup - 1])
+ .after(items[indexOfAddedItem]);
+ updateNewColOrder();
+ }
+ }
+ }
+ }
+ }
+ };
+ if (jgrid.msie && jgrid.msiever() === 8) {
+ $.expr[":"].hidden = function (elem) {
+ return elem.offsetWidth === 0 || elem.offsetHeight === 0 ||
+ elem.style.display === "none";
+ };
+ }
+ // requiere load multiselect before grid
+ jgrid._multiselect = false;
+ if ($UiMultiselect) {
+ if ($UiMultiselect.prototype._setSelected) {
+ var setSelected = $UiMultiselect.prototype._setSelected;
+ $UiMultiselect.prototype._setSelected = function (item, selected) {
+ // the method will be called if the user clicks "+" button on the item of "available" list
+ // or if the user clicks "-" button on the item of "selected" list.
+ // The parameter "selected" is equal true on click on the item of "selected" list
+ // and false on click on the item of "available" list.
+ var ret = setSelected.call(this, item, selected), elt = this.element,
+ iColItem = parseInt(item.data("optionLink").val(), 10);
+ if (selected && this.selectedList) {
+ // reorder items of selectedList
+ // all items of selectedList from one group have to be together
+ // all items of availableList from one group have to be together
+ reorderSelectedColumns.call(this, iColItem);
+
+ // apply the new sort order to the original selectbox
+ this.selectedList.find("li").each(function () {
+ if ($(this).data("optionLink")) {
+ $(this).data("optionLink").remove().appendTo(elt);
+ }
+ });
+ }
+ return ret;
+ };
+ }
+ if ($UiMultiselect.prototype.destroy) {
+ $UiMultiselect.prototype.destroy = function () {
+ var self = this;
+ self.element.show();
+ self.container.remove();
+ if ($.Widget === undefined) {
+ $.widget.prototype.destroy.apply(self, arguments);
+ } else {
+ $.Widget.prototype.destroy.apply(self, arguments);
+ }
+ };
+ }
+ jgrid._multiselect = true;
+ }
+
+ jgrid.extend({
+ sortableColumns: function (tblrow) {
+ return this.each(function () {
+ var ts = this, p = ts.p, tid = jqID(p.id);
+ if (!p || !p.sortable || !$.isFunction($.fn.sortable)) { return; }
+ function start() { p.disableClick = true; }
+ var sortableOpts = {
+ tolerance: "pointer",
+ axis: "x",
+ scrollSensitivity: "1",
+ items: ">th:not(:has(#jqgh_" + tid + "_cb" + ",#jqgh_" + tid + "_rn" + ",#jqgh_" + tid + "_subgrid),:hidden)",
+ placeholder: {
+ element: function (item) {
+ var el = $(document.createElement(item[0].nodeName))
+ .addClass(item[0].className + " ui-sortable-placeholder ui-state-highlight")
+ .removeClass("ui-sortable-helper")[0];
+ return el;
+ },
+ update: function (self, o) {
+ o.height(self.currentItem.innerHeight() - parseInt(self.currentItem.css("paddingTop") || 0, 10) - parseInt(self.currentItem.css("paddingBottom") || 0, 10));
+ o.width(self.currentItem.innerWidth() - parseInt(self.currentItem.css("paddingLeft") || 0, 10) - parseInt(self.currentItem.css("paddingRight") || 0, 10));
+ }
+ },
+ start: function () {
+ ts.grid.hDiv.scrollLeft = ts.grid.bDiv.scrollLeft;
+ },
+ update: function (event, ui) {
+ var th = $(">th", $(ui.item).parent()), tid1 = p.id + "_", permutation = [];
+ th.each(function () {
+ var id = $(">div", this).get(0).id.replace(/^jqgh_/, "").replace(tid1, ""),
+ iCol = p.iColByName[id];
+ if (iCol !== undefined) {
+ permutation.push(iCol);
+ }
+ });
+
+ $(ts).jqGrid("remapColumns", permutation, true, true);
+ if ($.isFunction(p.sortable.update)) {
+ p.sortable.update(permutation);
+ }
+ setTimeout(function () { p.disableClick = false; }, 50);
+ }
+ };
+ if (p.sortable.options) {
+ $.extend(sortableOpts, p.sortable.options);
+ } else if ($.isFunction(p.sortable)) {
+ p.sortable = { "update": p.sortable };
+ }
+ if (sortableOpts.start) {
+ var s = sortableOpts.start;
+ sortableOpts.start = function (e, ui) {
+ start();
+ s.call(this, e, ui);
+ };
+ } else {
+ sortableOpts.start = start;
+ }
+ if (p.sortable.exclude) {
+ sortableOpts.items += ":not(" + p.sortable.exclude + ")";
+ }
+ var $e = tblrow.sortable(sortableOpts), dataObj = $e.data("sortable") || $e.data("uiSortable") || $e.data("ui-sortable");
+ if (dataObj != null) {
+ dataObj.floating = true;
+ }
+ });
+ },
+ columnChooser: function (opts) {
+ var $self = this, self = $self[0], p = self.p, selector, select, dopts, mopts,
+ $dialogContent, multiselectData, listHeight,
+ colModel = p.colModel, nCol = colModel.length, colNames = p.colNames,
+ getMultiselectWidgetData = function ($elem) {
+ return ($UiMultiselect && $UiMultiselect.prototype && $elem.data($UiMultiselect.prototype.widgetFullName || $UiMultiselect.prototype.widgetName)) ||
+ $elem.data("ui-multiselect") || $elem.data("multiselect");
+ };
+
+ if ($("#colchooser_" + jqID(p.id)).length) { return; }
+ selector = $('');
+ select = $("select", selector);
+
+ function call(fn, obj) {
+ if (!fn) { return; }
+ if (typeof fn === "string") {
+ if ($.fn[fn]) {
+ $.fn[fn].apply(obj, $.makeArray(arguments).slice(2));
+ }
+ } else if ($.isFunction(fn)) {
+ fn.apply(obj, $.makeArray(arguments).slice(2));
+ }
+ }
+
+ opts = $.extend({
+ width: 400,
+ height: 240,
+ classname: null,
+ done: function (perm) {
+ if (perm) {
+ $self.jqGrid("remapColumns", perm, true);
+ }
+ },
+ /* msel is either the name of a ui widget class that
+ extends a multiselect, or a function that supports
+ creating a multiselect object (with no argument,
+ or when passed an object), and destroying it (when
+ passed the string "destroy"). */
+ msel: "multiselect",
+ /* "msel_opts" : {}, */
+
+ /* dlog is either the name of a ui widget class that
+ behaves in a dialog-like way, or a function, that
+ supports creating a dialog (when passed dlog_opts)
+ or destroying a dialog (when passed the string
+ "destroy")
+ */
+ dlog: "dialog",
+ dialog_opts: {
+ minWidth: 470,
+ dialogClass: "ui-jqdialog"
+ },
+ /* dlog_opts is either an option object to be passed
+ to "dlog", or (more likely) a function that creates
+ the options object.
+ The default produces a suitable options object for
+ ui.dialog */
+ dlog_opts: function (options) {
+ var buttons = {};
+ buttons[options.bSubmit] = function () {
+ options.apply_perm();
+ options.cleanup(false);
+ };
+ buttons[options.bCancel] = function () {
+ options.cleanup(true);
+ };
+ return $.extend(true, {
+ buttons: buttons,
+ close: function () {
+ options.cleanup(true);
+ },
+ modal: options.modal || false,
+ resizable: options.resizable || true,
+ width: options.width + 70,
+ resize: function () {
+ var widgetData = getMultiselectWidgetData(select),
+ $thisDialogContent = widgetData.container.closest(".ui-dialog-content");
+
+ if ($thisDialogContent.length > 0 && typeof $thisDialogContent[0].style === "object") {
+ $thisDialogContent[0].style.width = "";
+ } else {
+ $thisDialogContent.css("width", ""); // or just remove width style
+ }
+
+ widgetData.selectedList.height(Math.max(widgetData.selectedContainer.height() - widgetData.selectedActions.outerHeight() - 1, 1));
+ widgetData.availableList.height(Math.max(widgetData.availableContainer.height() - widgetData.availableActions.outerHeight() - 1, 1));
+ }
+ }, options.dialog_opts || {});
+ },
+ /* Function to get the permutation array, and pass it to the
+ "done" function */
+ apply_perm: function () {
+ var perm = new Array(p.colModel.length), i, gHead,
+ showHideColOptions = {
+ notSkipFrozen: opts.notSkipFrozen === undefined ? false : opts.notSkipFrozen,
+ skipSetGridWidth: true,
+ skipSetGroupHeaders: true
+ };
+
+ // we can use remapColumnsByName instead of remapColumns in general,
+ // but we try to hold the compatibility with old version. Thus we
+ // fill perm based on multiselectData.newColOrder
+ for (i = 0; i < p.colModel.length; i++) {
+ perm[i] = p.iColByName[multiselectData.newColOrder[i]];
+ }
+
+ $("option", select).each(function () {
+ if ($(this).is(":selected")) {
+ $self.jqGrid("showCol", colModel[this.value].name, showHideColOptions);
+ } else {
+ $self.jqGrid("hideCol", colModel[this.value].name, showHideColOptions);
+ }
+ });
+
+ if (opts.done) {
+ opts.done.call($self, perm);
+ }
+ if (p.groupHeader && (typeof p.groupHeader === "object" || $.isFunction(p.groupHeader))) {
+ $self.jqGrid("destroyGroupHeader", false);
+ p.groupHeader.groupHeaders = multiselectData.gh; // use modified groupHeader
+ if (p.pivotOptions != null && p.pivotOptions.colHeaders != null && p.pivotOptions.colHeaders.length > 1) {
+ gHead = p.pivotOptions.colHeaders;
+ for (i = 0; i < gHead.length; i++) {
+ // Multiple calls of setGroupHeaders for one grid are wrong,
+ // but there are produces good results in case of usage
+ // useColSpanStyle: false option. The rowspan values
+ // needed be increased in case of usage useColSpanStyle: true
+ if (gHead[i] && gHead[i].groupHeaders.length) {
+ $self.jqGrid("setGroupHeaders", gHead[i]);
+ }
+ }
+ } else {
+ $self.jqGrid("setGroupHeaders", p.groupHeader);
+ }
+ }
+ var newWidth = !p.autowidth && (p.widthOrg === undefined || p.widthOrg === "auto" || p.widthOrg === "100%") ? p.tblwidth : p.width;
+ if (newWidth !== p.width) {
+ $self.jqGrid("setGridWidth", newWidth, p.shrinkToFit);
+ }
+ },
+ /* Function to cleanup the dialog, and select. Also calls the
+ done function with no permutation (to indicate that the
+ columnChooser was aborted */
+ cleanup: function (calldone) {
+ call(opts.dlog, selector, "destroy");
+ call(opts.msel, select, "destroy");
+ selector.remove();
+ if (calldone && opts.done) {
+ opts.done.call($self);
+ }
+ },
+ msel_opts: {}
+ },
+ $self.jqGrid("getGridRes", "col"),
+ jgrid.col, opts || {});
+ if ($.ui) {
+ if ($UiMultiselect && $UiMultiselect.defaults) {
+ if (!jgrid._multiselect) {
+ // should be in language file
+ (jgrid.defaults != null && $.isFunction(jgrid.defaults.fatalError) ? jgrid.defaults.fatalError : alert)("Multiselect plugin loaded after jqGrid. Please load the plugin before the jqGrid!");
+ return;
+ }
+ // ??? the next line uses $.ui.multiselect.defaults which will be typically undefined
+ opts.msel_opts = $.extend($UiMultiselect.defaults, opts.msel_opts);
+ }
+ }
+ if (opts.caption) {
+ selector.attr("title", opts.caption);
+ }
+ if (opts.classname) {
+ selector.addClass(opts.classname);
+ select.addClass(opts.classname);
+ }
+ if (opts.width) {
+ $(">div", selector).css({ width: opts.width, margin: "0 auto" });
+ select.css("width", opts.width);
+ }
+ if (opts.height) {
+ $(">div", selector).css("height", opts.height);
+ select.css("height", opts.height - 10);
+ }
+
+ select.empty();
+ var gh = p.groupHeader != null ? p.groupHeader.groupHeaders : 0,
+ colHeader = {}, k, j, iCol, ghItem;
+ // fill colHeader for columns which have column header
+ if (gh) {
+ for (k = 0; k < gh.length; k++) {
+ ghItem = gh[k];
+ for (j = 0; j < ghItem.numberOfColumns; j++) {
+ iCol = p.iColByName[ghItem.startColumnName] + j;
+ colHeader[iCol] = $.isFunction(opts.buildItemText) ?
+ opts.buildItemText.call($self[0], {
+ iCol: iCol,
+ cm: colModel[iCol],
+ cmName: colModel[iCol].name,
+ colName: colNames[iCol],
+ groupTitleText: ghItem.titleText
+ }) :
+ $.jgrid.stripHtml(ghItem.titleText) + ": " +
+ $.jgrid.stripHtml(colNames[iCol] === "" ? colModel[iCol].name : colNames[iCol]);
+ }
+ }
+ }
+ // fill colHeader for all other columns
+ for (iCol = 0; iCol < nCol; iCol++) {
+ if (colHeader[iCol] === undefined) {
+ colHeader[iCol] = $.isFunction(opts.buildItemText) ?
+ opts.buildItemText.call($self[0], {
+ iCol: iCol,
+ cm: colModel[iCol],
+ cmName: colModel[iCol].name,
+ colName: colNames[iCol],
+ groupTitleText: null
+ }) :
+ $.jgrid.stripHtml(colNames[iCol]);
+ }
+ }
+ $.each(colModel, function (i) {
+ if (!this.hidedlg) {
+ select.append("" + colHeader[i] + " ");
+ }
+ });
+
+ dopts = $.isFunction(opts.dlog_opts) ? opts.dlog_opts.call($self, opts) : opts.dlog_opts;
+ call(opts.dlog, selector, dopts);
+ mopts = $.isFunction(opts.msel_opts) ? opts.msel_opts.call($self, opts) : opts.msel_opts;
+ call(opts.msel, select, mopts);
+
+ // fix height of elements of the multiselect widget
+ $dialogContent = $("#colchooser_" + jqID(p.id));
+
+ $dialogContent.css({ margin: "auto" });
+ $dialogContent.find(">div").css({ width: "100%", height: "100%", margin: "auto" });
+
+ multiselectData = getMultiselectWidgetData(select);
+ if (multiselectData) {
+ // grid property will be used to access the grid inside of _setSelected
+ multiselectData.grid = self;
+ if (gh) {
+ // make deep copy of groupHeaders to be able to hold changes of startColumnName,
+ // but to apply the changes only after the user click OK button (not Cancel)
+ multiselectData.gh = $.extend(true, [], gh);
+
+ // filling the helper array inGroup. It contains
+ // an item for every column. The value is undefined if the column
+ // not belongs to a header group and it is 0-based index of the
+ // header group (the index in gh array) if the column belongs to
+ // a header group. The array inGroup helps us to detect whether
+ // two columns belong to the same group or not.
+ multiselectData.inGroup = new Array(p.colModel.length); // allocate array with undefined values
+
+ var iGrp, headerItem;
+ for (iGrp = 0; iGrp < gh.length; iGrp++) {
+ headerItem = gh[iGrp];
+ for (iCol = 0; iCol < headerItem.numberOfColumns; iCol++) {
+ multiselectData.inGroup[p.iColByName[headerItem.startColumnName] + iCol] = iGrp;
+ }
+ }
+ }
+ multiselectData.newColOrder = $.map(colModel, function (cm) { return cm.name; });
+ multiselectData.container.css({ width: "100%", height: "100%", margin: "auto" });
+
+ multiselectData.selectedContainer.css({ width: multiselectData.options.dividerLocation * 100 + "%", height: "100%", margin: "auto", boxSizing: "border-box" });
+ multiselectData.availableContainer.css({ width: (100 - multiselectData.options.dividerLocation * 100) + "%", height: "100%", margin: "auto", boxSizing: "border-box" });
+
+ // set height for both selectedList and availableList
+ multiselectData.selectedList.css("height", "auto");
+ multiselectData.availableList.css("height", "auto");
+ listHeight = Math.max(multiselectData.selectedList.height(), multiselectData.availableList.height());
+ listHeight = Math.min(listHeight, $(window).height());
+ multiselectData.selectedList.css("height", listHeight);
+ multiselectData.availableList.css("height", listHeight);
+ if (multiselectData.options != null && multiselectData.options.sortable) {
+ multiselectData.selectedList.on("sortupdate", function (e, ui) {
+ // remove fixed inline style values of width and height
+ // added during gragging
+ reorderSelectedColumns.call(
+ multiselectData,
+ parseInt(ui.item.data("optionLink").val(), 10)
+ );
+ ui.item.css({ width: "", height: "" });
+ if ($.isFunction(opts.sortUpdate)) {
+ opts.sortUpdate.call(self, e, ui);
+ }
+ });
+ }
+ if ($.isFunction(opts.init)) {
+ opts.init.call(self, multiselectData);
+ }
+ }
+ },
+ sortableRows: function (opts) {
+ // Can accept all sortable options and events
+ return this.each(function () {
+ var $t = this, grid = $t.grid, p = $t.p;
+ if (!grid) { return; }
+ // Currently we disable a treeGrid sortable
+ if (p.treeGrid) { return; }
+ if ($.fn.sortable) {
+ opts = $.extend({
+ cursor: "move",
+ axis: "y",
+ items: ">tbody>.jqgrow"
+ },
+ opts || {});
+ if (opts.start && $.isFunction(opts.start)) {
+ opts._start_ = opts.start;
+ delete opts.start;
+ } else { opts._start_ = false; }
+ if (opts.update && $.isFunction(opts.update)) {
+ opts._update_ = opts.update;
+ delete opts.update;
+ } else { opts._update_ = false; }
+ opts.start = function (ev, ui) {
+ $(ui.item).css("border-width", "0");
+ $("td", ui.item).each(function (i) {
+ this.style.width = grid.cols[i].style.width;
+ });
+ if (p.subGrid) {
+ var subgid = $(ui.item).attr("id");
+ try {
+ $($t).jqGrid("collapseSubGridRow", subgid);
+ } catch (ignore) { }
+ }
+ if (opts._start_) {
+ opts._start_.apply(this, [ev, ui]);
+ }
+ };
+ opts.update = function (ev, ui) {
+ $(ui.item).css("border-width", "");
+ if (p.rownumbers === true) {
+ $("td.jqgrid-rownum", $t.rows).each(function (i) {
+ $(this).html(i + 1 + (parseInt(p.page, 10) - 1) * parseInt(p.rowNum, 10));
+ });
+ }
+ if (opts._update_) {
+ opts._update_.apply(this, [ev, ui]);
+ }
+ };
+ $($t).sortable(opts);
+ /*if ($.isFunction($.fn.disableSelection)) {
+ // The method disableSelection exists starting with jQuery UI 1.6,
+ // but it's declared as deprecated since jQuery UI 1.9
+ // see http://jqueryui.com/upgrade-guide/1.9/#deprecated-disableselection-and-enableselection
+ // so we use disableSelection only if it exists
+ var jQueryUiVersion = $.ui != null && typeof $.ui.version === "string" ?
+ $.ui.version.match(/(\d+)\.(\d+).(\d+)/) : [];
+ // jQuery UI version is: jQueryUiVersion[1].jQueryUiVersion[2].jQueryUiVersion[3]
+ if (jQueryUiVersion.length === 4 && jQueryUiVersion[1] === "1" &&
+ jQueryUiVersion[2] > 5 && jQueryUiVersion[2] < 9) {
+ // disable selection only for old jQuery UI
+ $($t.tBodies[0]).children("tr.jqgrow").disableSelection();
+ }
+ }*/
+ }
+ });
+ },
+ gridDnD: function (opts) {
+ return this.each(function () {
+ var $t = this, j, cn;
+ if (!$t.grid) { return; }
+ // Currently we disable a treeGrid drag and drop
+ if ($t.p.treeGrid) { return; }
+ if (!$.fn.draggable || !$.fn.droppable) { return; }
+ function updateDnD() {
+ var datadnd = $.data($t, "dnd");
+ $("tr.jqgrow:not(.ui-draggable)", $t).draggable($.isFunction(datadnd.drag) ? datadnd.drag.call($($t), datadnd) : datadnd.drag);
+ }
+ var appender = "";
+ if ($("#jqgrid_dnd")[0] === undefined) {
+ $("body").append(appender);
+ }
+
+ if (typeof opts === "string" && opts === "updateDnD" && $t.p.jqgdnd === true) {
+ updateDnD();
+ return;
+ }
+ opts = $.extend({
+ drag: function (opts1) {
+ return $.extend({
+ start: function (ev, ui) {
+ var i, subgid;
+ // if we are in subgrid mode try to collapse the node
+ if ($t.p.subGrid) {
+ subgid = $(ui.helper).attr("id");
+ try {
+ $($t).jqGrid("collapseSubGridRow", subgid);
+ } catch (ignore) { }
+ }
+ // hack
+ // drag and drop does not insert tr in table, when the table has no rows
+ // we try to insert new empty row on the target(s)
+ for (i = 0; i < $.data($t, "dnd").connectWith.length; i++) {
+ if ($($.data($t, "dnd").connectWith[i]).jqGrid("getGridParam", "reccount") === 0) {
+ $($.data($t, "dnd").connectWith[i]).jqGrid("addRowData", "jqg_empty_row", {});
+ }
+ }
+ ui.helper.addClass("ui-state-highlight");
+ $("td", ui.helper).each(function (iCol) {
+ this.style.width = $t.grid.headers[iCol].width + "px";
+ });
+ if (opts1.onstart && $.isFunction(opts1.onstart)) { opts1.onstart.call($($t), ev, ui); }
+ },
+ stop: function (ev, ui) {
+ var i, ids;
+ if (ui.helper.dropped && !opts1.dragcopy) {
+ ids = $(ui.helper).attr("id");
+ if (ids === undefined) { ids = $(this).attr("id"); }
+ $($t).jqGrid("delRowData", ids);
+ }
+ // if we have a empty row inserted from start event try to delete it
+ for (i = 0; i < $.data($t, "dnd").connectWith.length; i++) {
+ $($.data($t, "dnd").connectWith[i]).jqGrid("delRowData", "jqg_empty_row");
+ }
+ if (opts1.onstop && $.isFunction(opts1.onstop)) { opts1.onstop.call($($t), ev, ui); }
+ }
+ }, opts1.drag_opts || {});
+ },
+ drop: function (opts1) {
+ return $.extend({
+ accept: function (d) {
+ if (!$(d).hasClass("jqgrow")) { return d; }
+ var tid = $(d).closest("table.ui-jqgrid-btable");
+ if (tid.length > 0 && $.data(tid[0], "dnd") !== undefined) {
+ var cn1 = $.data(tid[0], "dnd").connectWith;
+ return $.inArray("#" + jqID(this.id), cn1) !== -1 ? true : false;
+ }
+ return false;
+ },
+ drop: function (ev, ui) {
+ if (!$(ui.draggable).hasClass("jqgrow")) { return; }
+ var accept = $(ui.draggable).attr("id");
+ var getdata = ui.draggable.parent().parent().jqGrid("getRowData", accept);
+ if (!opts1.dropbyname) {
+ var i = 0, tmpdata = {}, nm, key;
+ var dropmodel = $("#" + jqID(this.id)).jqGrid("getGridParam", "colModel");
+ try {
+ for (key in getdata) {
+ if (getdata.hasOwnProperty(key)) {
+ nm = dropmodel[i].name;
+ if (!(nm === "cb" || nm === "rn" || nm === "subgrid")) {
+ if (getdata.hasOwnProperty(key) && dropmodel[i]) {
+ tmpdata[nm] = getdata[key];
+ }
+ }
+ i++;
+ }
+ }
+ getdata = tmpdata;
+ } catch (ignore) { }
+ }
+ ui.helper.dropped = true;
+ if (opts1.beforedrop && $.isFunction(opts1.beforedrop)) {
+ //parameters to this callback - event, element, data to be inserted, sender, reciever
+ // should return object which will be inserted into the reciever
+ var datatoinsert = opts1.beforedrop.call(this, ev, ui, getdata, $("#" + jqID($t.p.id)), $(this));
+ if (datatoinsert !== undefined && datatoinsert !== null && typeof datatoinsert === "object") { getdata = datatoinsert; }
+ }
+ if (ui.helper.dropped) {
+ var grid;
+ if (opts1.autoid) {
+ if ($.isFunction(opts1.autoid)) {
+ grid = opts1.autoid.call(this, getdata);
+ } else {
+ grid = Math.ceil(Math.random() * 1000);
+ grid = opts1.autoidprefix + grid;
+ }
+ }
+ // NULL is interpreted as undefined while null as object
+ $("#" + jqID(this.id)).jqGrid("addRowData", grid, getdata, opts1.droppos);
+ getdata[$t.p.localReader.id] = grid;
+ }
+ if (opts1.ondrop && $.isFunction(opts1.ondrop)) { opts1.ondrop.call(this, ev, ui, getdata); }
+ }
+ }, opts1.drop_opts || {});
+ },
+ onstart: null,
+ onstop: null,
+ beforedrop: null,
+ ondrop: null,
+ drop_opts: {
+ //activeClass: "ui-state-active",
+ //hoverClass: "ui-state-hover"
+ },
+ drag_opts: {
+ revert: "invalid",
+ helper: "clone",
+ cursor: "move",
+ appendTo: "#jqgrid_dnd",
+ zIndex: 5000
+ },
+ dragcopy: false,
+ dropbyname: false,
+ droppos: "first",
+ autoid: true,
+ autoidprefix: "dnd_"
+ }, opts || {});
+
+ if (!opts.connectWith) { return; }
+ opts.connectWith = opts.connectWith.split(",");
+ opts.connectWith = $.map(opts.connectWith, function (n) { return $.trim(n); });
+ $.data($t, "dnd", opts);
+
+ if ($t.p.reccount !== 0 && !$t.p.jqgdnd) {
+ updateDnD();
+ }
+ $t.p.jqgdnd = true;
+ for (j = 0; j < opts.connectWith.length; j++) {
+ cn = opts.connectWith[j];
+ $(cn).droppable($.isFunction(opts.drop) ? opts.drop.call($($t), opts) : opts.drop);
+ }
+ });
+ },
+ gridResize: function (opts) {
+ return this.each(function () {
+ var $t = this, grid = $t.grid, p = $t.p, bdivSelector = p.gView + ">.ui-jqgrid-bdiv", onlyHorizontal = false, sel, gridHeight = p.height;
+ if (!grid || !$.fn.resizable) { return; }
+ opts = $.extend({}, opts || {});
+ if (opts.alsoResize) {
+ opts._alsoResize_ = opts.alsoResize;
+ delete opts.alsoResize;
+ } else {
+ opts._alsoResize_ = false;
+ }
+ if (opts.stop && $.isFunction(opts.stop)) {
+ opts._stop_ = opts.stop;
+ delete opts.stop;
+ } else {
+ opts._stop_ = false;
+ }
+ opts.stop = function (ev, ui) {
+ $($t).jqGrid("setGridWidth", ui.size.width, opts.shrinkToFit);
+ $(p.gView + ">.ui-jqgrid-titlebar").css("width", "");
+ if (!onlyHorizontal) {
+ $($t).jqGrid("setGridParam", { height: $(bdivSelector).height() });
+ } else {
+ $(sel).each(function () {
+ $(this).css("height", "");
+ });
+ if (gridHeight === "auto" || gridHeight === "100%") {
+ $(grid.bDiv).css("height", gridHeight);
+ }
+ }
+ if ($t.fixScrollOffsetAndhBoxPadding) {
+ $t.fixScrollOffsetAndhBoxPadding();
+ }
+ if (opts._stop_) { opts._stop_.call($t, ev, ui); }
+ };
+ sel = bdivSelector;
+ if ((gridHeight === "auto" || gridHeight === "100%") && opts.handles === undefined) {
+ opts.handles = "e,w";
+ }
+ if (opts.handles) {
+ // test for "e, w"
+ var ar = $.map(String(opts.handles).split(","), function (item) {
+ return $.trim(item);
+ });
+ if (ar.length === 2 && ((ar[0] === "e" && ar[1] === "w") || (ar[1] === "e" && ar[1] === "w"))) {
+ sel = p.gView + ">div:not(.frozen-div)";
+ onlyHorizontal = true;
+ if (p.pager) {
+ sel += "," + p.pager;
+ }
+ }
+ }
+ if (opts._alsoResize_) {
+ opts.alsoResize = sel + "," + opts._alsoResize_;
+ } else {
+ opts.alsoResize = sel;
+ }
+ delete opts._alsoResize_;
+ $(p.gBox).resizable(opts);
+ });
+ }
+ });
+ // end module grid.jqueryui
+
+ /**
+ * jqGrid pivot functions
+ * Copyright (c) 2008-2014, Tony Tomov, tony@trirand.com, http://trirand.com/blog/
+ * Copyright (c) 2014-2017, Oleg Kiriljuk, oleg.kiriljuk@ok-soft-gmbh.com
+ * The modul is created initially by Tony Tomov and it's full rewritten
+ * for free jqGrid: https://github.com/free-jqgrid/jqGrid by Oleg Kiriljuk
+ * Dual licensed under the MIT and GPL licenses:
+ * http://www.opensource.org/licenses/mit-license.php
+ * http://www.gnu.org/licenses/gpl-2.0.html
+ */
+ // begin module grid.pivot
+ function Aggregation(aggregator, context, pivotOptions) {
+ if (!(this instanceof Aggregation)) {
+ return new Aggregation(aggregator);
+ }
+ //this.result = undefined;
+ //this.count = undefined;
+ this.aggregator = aggregator;
+ this.finilized = false;
+ this.context = context;
+ this.pivotOptions = pivotOptions;
+ }
+ Aggregation.prototype.calc = function (v, fieldName, row, iRow, rows) {
+ var self = this;
+ if (v !== undefined) {
+ self.result = self.result || 0; // change undefined to 0
+ v = parseFloat(v);
+ switch (self.aggregator) {
+ case "sum":
+ self.result += v;
+ break;
+ case "count":
+ self.result++;
+ break;
+ case "avg":
+ if (self.finilized) {
+ self.count = self.count || 0; // change undefined to 0
+ self.result = (self.result * self.count + v) / (self.count + 1);
+ self.count++;
+ } else {
+ self.result += v;
+ self.count = self.count || 0; // change undefined to 0
+ self.count++;
+ }
+ break;
+ case "min":
+ self.result = Math.min(self.result, v);
+ break;
+ case "max":
+ self.result = Math.max(self.result, v);
+ break;
+ default:
+ if ($.isFunction(self.aggregator)) {
+ self.result = self.aggregator.call(self.context, {
+ previousResult: self.result,
+ value: v,
+ fieldName: fieldName,
+ item: row,
+ iItem: iRow,
+ items: rows
+ });
+ }
+ break;
+ }
+ }
+ };
+ Aggregation.prototype.getResult = function (obj, propName, forceSaving) {
+ var self = this;
+ if (self.result !== undefined || forceSaving) {
+ if (forceSaving) {
+ if (self.result !== undefined) {
+ self.result = 0;
+ self.count = 0;
+ }
+ }
+ if (self.result !== undefined && !self.finilized && self.aggregator === "avg") {
+ self.result = self.result / self.count;
+ self.finilized = true;
+ }
+ obj[propName] = self.result;
+ }
+ };
+
+ function ArrayOfFieldsets(trimByCollect, caseSensitive, skipSort, dimension, fieldName) {
+ var iField, dimensionLength = dimension.length, dimensionItem, self = this,
+ stringCompare = function (a, b) {
+ var a1 = a, b1 = b;
+ if (a1 == null) { a1 = ""; } // we will place undefined and null values as the lowest TOGETHER with ""
+ if (b1 == null) { b1 = ""; }
+ // be sure that we have no other input data (Number, Date and so on)
+ a1 = String(a1);
+ b1 = String(b1);
+ if (!this.caseSensitive) {
+ a1 = a1.toUpperCase();
+ b1 = b1.toUpperCase();
+ }
+ if (a1 === b1) {
+ if (a === b) {//typeof a === typeof b) {
+ return 0;
+ }
+ // either a or b is undefined or null
+ if (a === undefined) { return -1; } // make undefined less as all other
+ if (b === undefined) { return 1; }
+ if (a === null) { return -1; } // make null less as all other with the exception undefined
+ if (b === null) { return 1; }
+ }
+ if (a1 < b1) {
+ return -1;
+ }
+ return 1;
+ },
+ numberCompare = function (a, b) {
+ a = Number(a);
+ b = Number(b);
+ if (a === b) {
+ return 0;
+ }
+ if (a < b) {
+ return -1;
+ }
+ return 1;
+ },
+ integerCompare = function (a, b) {
+ a = Math.floor(Number(a));
+ b = Math.floor(Number(b));
+ if (a === b) {
+ return 0;
+ }
+ if (a < b) {
+ return -1;
+ }
+ return 1;
+ };
+
+ self.items = [];
+ self.indexesOfSourceData = [];
+ self.trimByCollect = trimByCollect;
+ self.caseSensitive = caseSensitive;
+ self.skipSort = skipSort;
+ self.fieldLength = dimensionLength;
+ self.fieldNames = new Array(dimensionLength);
+ self.fieldSortDirection = new Array(dimensionLength);
+ self.fieldCompare = new Array(dimensionLength); // 0 - number, 1 - integer, 2 - string, one can extend for Date and other
+ for (iField = 0; iField < dimensionLength; iField++) {
+ dimensionItem = dimension[iField];
+ self.fieldNames[iField] = dimensionItem[fieldName || "dataName"];
+ switch (dimensionItem.sorttype) {
+ case "integer":
+ case "int":
+ self.fieldCompare[iField] = integerCompare;
+ break;
+ case "number":
+ case "currency":
+ case "float":
+ self.fieldCompare[iField] = numberCompare;
+ break;
+ default:
+ self.fieldCompare[iField] = $.isFunction(dimensionItem.compare) ? dimensionItem.compare : stringCompare;
+ break;
+ }
+ self.fieldSortDirection[iField] = dimensionItem.sortorder === "desc" ? -1 : 1;
+ }
+ }
+ ArrayOfFieldsets.prototype.compareVectorsEx = function (vector1, vector2) {
+ var self = this, fieldLength = self.fieldLength, iField, compareResult;
+ for (iField = 0; iField < fieldLength; iField++) {
+ compareResult = self.fieldCompare[iField](vector1[iField], vector2[iField]);
+ if (compareResult !== 0) {
+ return {
+ index: iField,
+ result: compareResult
+ };
+ }
+ }
+ return {
+ index: -1,
+ result: 0
+ };
+ };
+ ArrayOfFieldsets.prototype.getIndexOfDifferences = function (vector1, vector2) {
+ if (vector2 === null || vector1 === null) {
+ return 0;
+ }
+ return this.compareVectorsEx(vector1, vector2).index;
+ };
+ ArrayOfFieldsets.prototype.compareVectors = function (vector1, vector2) {
+ var compareRestlts = this.compareVectorsEx(vector1, vector2),
+ sortDirection = compareRestlts.index >= 0 ? this.fieldSortDirection[compareRestlts.index] : 1;
+ return sortDirection > 0 ? compareRestlts.result : -compareRestlts.result;
+ };
+ ArrayOfFieldsets.prototype.getItem = function (index) {
+ return this.items[index];
+ };
+ ArrayOfFieldsets.prototype.getIndexLength = function () {
+ return this.items.length;
+ };
+ ArrayOfFieldsets.prototype.getIndexesOfSourceData = function (index) {
+ return this.indexesOfSourceData[index];
+ };
+ ArrayOfFieldsets.prototype.createDataIndex = function (data) {
+ var self = this, iRow, nRows = data.length, fieldLength = self.fieldLength, values, v,
+ fieldNames = self.fieldNames, indexesOfSourceData = self.indexesOfSourceData, iField, compareResult, i, item,
+ items = self.items, iMin, iMax;
+
+ for (iRow = 0; iRow < nRows; iRow++) {
+ item = data[iRow];
+
+ // build the set of fields with data of the current item
+ values = new Array(fieldLength);
+ for (iField = 0; iField < fieldLength; iField++) {
+ v = item[fieldNames[iField]];
+ if (v !== undefined) {
+ if (typeof v === "string" && self.trimByCollect) {
+ v = $.trim(v);
+ }
+ values[iField] = v;
+ }
+ }
+
+ // compare values with items having index iMax and iMin
+ // If we use skipSort:true option then we compare always
+ // with iMax item only.
+ iMin = 0;
+ iMax = items.length - 1;
+ if (iMax < 0) {
+ items.push(values);
+ indexesOfSourceData.push([iRow]);
+ continue;
+ }
+ compareResult = self.compareVectors(values, items[iMax]);
+ if (compareResult === 0) {
+ indexesOfSourceData[iMax].push(iRow);
+ continue;
+ }
+ if (compareResult === 1 || self.skipSort) {
+ // in case of the empty array this.items or if the values is larger as the
+ // the max (last) element of this.items: append values to the array this.items
+ items.push(values);
+ indexesOfSourceData.push([iRow]);
+ continue;
+ }
+ compareResult = self.compareVectors(items[0], values);
+ if (compareResult === 1) {
+ // if the min (first) element values is larger as the values:
+ // insert the values as the first element of the array this.items
+ items.unshift(values);
+ indexesOfSourceData.unshift([iRow]);
+ continue;
+ }
+ if (compareResult === 0) {
+ indexesOfSourceData[0].push(iRow);
+ continue;
+ }
+ // we are sure that items[iMin] < values < items[iMax]
+ while (true) {
+ if (iMax - iMin < 2) {
+ // no identical items are found we need to insert the item at i index
+ items.splice(iMax, 0, values); // insert after iMin
+ indexesOfSourceData.splice(iMax, 0, [iRow]);
+ break;
+ }
+ i = Math.floor((iMin + iMax) / 2); // | 0 means Math.floor, but it's faster sometimes.
+ compareResult = self.compareVectors(items[i], values);
+ if (compareResult === 0) {
+ indexesOfSourceData[i].push(iRow);
+ break;
+ }
+ if (compareResult === 1) {
+ iMax = i;
+ } else {
+ iMin = i;
+ }
+ }
+ }
+ };
+
+ jgrid.extend({
+ pivotSetup: function (data, options) {
+ // data should come in json format
+ // The function return the new colModel and the transformed data
+ // again with group setup options which then will be passed to the grid
+ var self = this[0], isArray = $.isArray, summaries = {},
+ groupingView = {
+ groupField: [],
+ groupSummary: [],
+ groupSummaryPos: []
+ },
+ groupOptions = {
+ grouping: true,
+ groupingView: groupingView
+ },
+ o = $.extend({
+ totals: false, // replacement for rowTotals. totalText and totalHeader can be used additionally
+ useColSpanStyle: false,
+ trimByCollect: true,
+ skipSortByX: false,
+ skipSortByY: false,
+ caseSensitive: false,
+ footerTotals: false, // replacement colTotals. footerAggregator option and totalText properties of xDimension[i] can be used additionally
+ groupSummary: true,
+ groupSummaryPos: "header",
+ frozenStaticCols: false,
+ defaultFormatting: true,
+ data: data
+ }, options || {}),
+ row, i, k, nRows = data.length, x, y, cm, iRow, cmName, iXData, itemXData, pivotInfos, rows,
+ xDimension = o.xDimension, yDimension = o.yDimension, aggregates = o.aggregates, aggrContext,
+ isRowTotal = o.totalText || o.totals || o.rowTotals || o.totalHeader, aggrTotal, gi,
+ xlen = isArray(xDimension) ? xDimension.length : 0,
+ ylen = isArray(yDimension) ? yDimension.length : 0,
+ aggrlen = isArray(aggregates) ? aggregates.length : 0,
+ headerLevels = ylen - (aggrlen === 1 ? 1 : 0),
+ colHeaders = [], hasGroupTotal = [], colModel = [], outputItems = [],
+ additionalProperties = ["pivotInfos"],
+ aggrContextTotalRows = new Array(aggrlen), aggrContextGroupTotalRows = new Array(ylen),
+ xIndexLength, indexesOfDataWithTheSameXValues, iYData, itemYData, indexesOfDataWithTheSameYValues,
+ iRows, agr, outputItem, previousY, groupHeaders, iRowsY, xIndex, yIndex, yIndexLength,
+ indexDataBy = function (dimension, skipSort, compareVectors) {
+ var index = new ArrayOfFieldsets(o.trimByCollect, o.caseSensitive, skipSort, dimension);
+ if ($.isFunction(compareVectors)) {
+ index.compareVectorsEx = compareVectors;
+ }
+ index.createDataIndex(data);
+ return index;
+ },
+ buildColModelItem = function (colType, agr1, iAggr, level, iyData) {
+ var label, name, cmItem;
+ switch (colType) {
+ case 1: // total group
+ label = yDimension[level].totalText || "{0} {1} {2}";
+ name = "y" + iyData + "t" + level;
+ break;
+ case 2: // grand total
+ label = o.totalText || "{0}";
+ name = "t";
+ break;
+ //case 0: // standard column
+ default:
+ label = aggrlen > 1 ?
+ agr1.label || "{0}" :
+ ($.isFunction(yDimension[level].label) ?
+ yDimension[level].label :
+ yIndex.getItem(iyData)[level]);
+ name = "y" + iyData;
+ break;
+ }
+ cmItem = $.extend({}, agr1, {
+ name: name + (aggrlen > 1 ? "a" + iAggr : ""),
+ label: $.isFunction(label) ?
+ (label.call(self, colType === 2 ?
+ { aggregate: agr1, iAggregate: iAggr, pivotOptions: o } :
+ (colType === 1 ?
+ { yIndex: yIndex.getItem(iyData), aggregate: agr1, iAggregate: iAggr, yLevel: level, pivotOptions: o } :
+ { yData: yIndex.getItem(iyData)[level], yIndex: yIndex.getItem(iyData), yLevel: level, pivotOptions: o }))) :
+ (jgrid.template.apply(self, colType === 2 ?
+ [String(label), agr1.aggregator, agr1.member, iAggr] :
+ [String(label), agr1.aggregator, agr1.member, yIndex.getItem(iyData)[level], level]))
+ });
+ delete cmItem.member;
+ delete cmItem.aggregator;
+ return cmItem;
+ },
+ addColumnToColModel = function (colType, level, iyData) {
+ var iAggr, aggregate;
+ for (iAggr = 0; iAggr < aggrlen; iAggr++) {
+ aggregate = aggregates[iAggr];
+ if (aggregate.template === undefined && aggregate.formatter === undefined && o.defaultFormatting) {
+ aggregate.template = aggregate.aggregator === "count" ? "integer" : "number";
+ }
+ colModel.push(buildColModelItem(colType, aggregate, iAggr, level, iyData));
+ }
+ },
+ addGroupTotalHeaders = function (iyData, level, previousY1) {
+ var iLevel, j, totalHeader, headerOnTop;
+ for (iLevel = headerLevels - 1; iLevel >= level; iLevel--) {
+ if (hasGroupTotal[iLevel]) {
+ for (j = 0; j <= iLevel; j++) {
+ groupHeaders = colHeaders[j].groupHeaders;
+ groupHeaders[groupHeaders.length - 1].numberOfColumns += aggrlen;
+ }
+ y = yDimension[iLevel];
+ totalHeader = y.totalHeader;
+ headerOnTop = y.headerOnTop;
+ for (j = iLevel + 1; j <= headerLevels - 1; j++) {
+ colHeaders[j].groupHeaders.push({
+ titleText: ((headerOnTop && j === iLevel + 1) || (!headerOnTop && j === headerLevels - 1)) ?
+ ($.isFunction(totalHeader) ?
+ totalHeader.call(self, previousY1, iLevel) :
+ jgrid.template.call(self, String(totalHeader || ""), previousY1[iLevel], iLevel)) :
+ "",
+ startColumnName: "y" + (iyData - 1) + "t" + iLevel + (aggrlen === 1 ? "" : "a0"),
+ numberOfColumns: aggrlen
+ });
+ }
+ }
+ }
+ },
+ createTotalAggregation = function (iAggr) {
+ var aggrGroup = new Aggregation(aggregates[iAggr].aggregator === "count" ? "sum" : aggregates[iAggr].aggregator, self, options);
+ aggrGroup.groupInfo = { iRows: [], rows: [], ys: [], iYs: [] };
+ return aggrGroup;
+ },
+ initializeGroupTotals = function () {
+ var iLevel, iAggr;
+ for (iLevel = headerLevels - 1; iLevel >= 0; iLevel--) {
+ if (hasGroupTotal[iLevel]) {
+ if (aggrContextGroupTotalRows[iLevel] == null) {// first call
+ aggrContextGroupTotalRows[iLevel] = new Array(aggrlen);
+ }
+ for (iAggr = 0; iAggr < aggrlen; iAggr++) {
+ aggrContextGroupTotalRows[iLevel][iAggr] = createTotalAggregation(iAggr);
+ }
+ }
+ }
+ },
+ finalizeGroupTotals = function (iyData, itemYData1, previousY1, iAggr) {
+ var iLevel, level = yIndex.getIndexOfDifferences(itemYData1, previousY1), fieldName, aggrGroup;
+
+ if (previousY1 !== null) {
+ // test whether the group is finished and one need to get results
+ level = Math.max(level, 0); // change -1 to 0 for the last call (itemYData === previousY)
+ for (iLevel = headerLevels - 1; iLevel >= level; iLevel--) {
+ fieldName = "y" + iyData + "t" + iLevel + (aggrlen > 1 ? "a" + iAggr : "");
+ if (hasGroupTotal[iLevel] && outputItem[fieldName] === undefined) {
+ aggrGroup = aggrContextGroupTotalRows[iLevel][iAggr];
+ aggrGroup.getResult(outputItem, fieldName);
+ outputItem.pivotInfos[fieldName] = {
+ colType: 1,
+ iA: iAggr,
+ a: aggregates[iAggr],
+ level: iLevel,
+ iRows: aggrGroup.groupInfo.iRows,
+ rows: aggrGroup.groupInfo.rows,
+ ys: aggrGroup.groupInfo.ys,
+ iYs: aggrGroup.groupInfo.iYs
+ };
+ if (itemYData1 !== previousY1) {
+ aggrContextGroupTotalRows[iLevel][iAggr] = createTotalAggregation(iAggr);
+ }
+ }
+ }
+ }
+ },
+ calculateGroupTotals = function (itemYData1, previousY1, aggregate, iAggr, row1, iRow1, iyData) {
+ // the method will be called at the first time with previousY === null in every output row
+ // and finally with itemYData === previousY for getting results of all aggregation contexts
+ var iLevel, aggrGroup, groupInfo;
+
+ if (itemYData1 !== previousY1) { // not the last call in the row
+ for (iLevel = headerLevels - 1; iLevel >= 0; iLevel--) {
+ if (hasGroupTotal[iLevel]) {
+ aggrGroup = aggrContextGroupTotalRows[iLevel][iAggr];
+ aggrGroup.calc(row1[aggregate.member], aggregate.member, row1, iRow1, data);
+ groupInfo = aggrGroup.groupInfo;
+ if ($.inArray(iyData, groupInfo.iYs) < 0) {
+ groupInfo.iYs.push(iyData);
+ groupInfo.ys.push(itemYData1);
+ }
+ if ($.inArray(iRow1, groupInfo.iRows) < 0) {
+ groupInfo.iRows.push(iRow1);
+ groupInfo.rows.push(row1);
+ }
+ }
+ }
+ }
+ };
+
+ if (xlen === 0 || aggrlen === 0) {
+ throw ("xDimension or aggregates options are not set!");
+ }
+
+ // ****************************************************************
+ // The step 1: scan input data and build the list of unique indexes
+ // ****************************************************************
+ xIndex = indexDataBy(xDimension, o.skipSortByX, o.compareVectorsByX);
+ yIndex = indexDataBy(yDimension, o.skipSortByY, o.compareVectorsByY);
+
+ // save to be used probably later
+ options.xIndex = xIndex;
+ options.yIndex = yIndex;
+
+ // *******************************************
+ // The step 2: build colModel and groupOptions
+ // *******************************************
+ // fill the first xlen columns of colModel and fill the groupOptions
+ // the names of the first columns will be "x"+i. The first column have the name "x0".
+ for (i = 0; i < xlen; i++) {
+ x = xDimension[i];
+ cm = {
+ name: "x" + i,
+ label: x.label != null ?
+ ($.isFunction(x.label) ? x.label.call(self, x, i, o) : x.label) :
+ x.dataName,
+ frozen: o.frozenStaticCols
+ };
+ if (i < xlen - 1 && !x.skipGrouping && !x.additionalProperty) {
+ // based on xDimension levels build grouping
+ groupingView.groupField.push(cm.name);
+ groupingView.groupSummary.push(o.groupSummary);
+ groupingView.groupSummaryPos.push(o.groupSummaryPos);
+ }
+ cm = $.extend(cm, x);
+ delete cm.dataName;
+ delete cm.footerText;
+ if (!x.additionalProperty) {
+ colModel.push(cm);
+ groupOptions.sortname = cm.name;
+ } else {
+ additionalProperties.push(cm.name);
+ }
+ }
+ if (xlen < 2) {
+ groupOptions.grouping = false; // no grouping is needed
+ }
+ groupingView.hideFirstGroupCol = true;
+
+ // Fill hasGroupTotal and groupColumnsPerLevel arrays
+ // The hasGroupTotal just shows whether one need create additional totals for every group.
+ for (i = 0; i < ylen; i++) {
+ y = yDimension[i];
+ hasGroupTotal.push(y.totals || y.rowTotals || y.totalText || y.totalHeader ? true : false);
+ }
+
+ // fill other columns of colModel based on collected uniqueYData and aggregates options
+ // the names of the first columns will be "y"+i in case of one aggregate and
+ // "y"+i+"a"+k in case of multiple aggregates. The name of the first "y"-column is "y0" or "y0a0"
+ // The next function build and insert item in colModel
+ // colType: 0 - means standard column, 1 - total group, 2 - grand total
+ previousY = yIndex.getItem(0);
+ addColumnToColModel(0, ylen - 1, 0); // add standard column
+ yIndexLength = yIndex.getIndexLength();
+ for (iYData = 1; iYData < yIndexLength; iYData++) {
+ itemYData = yIndex.getItem(iYData);
+ /*
+ * find where (on which level) the itemYData have the differences to
+ * the previous y (previousY). If the level has (totals:true/rowTotals:true) in yDimension
+ * then one should insert new total columns for all levels starting with the highest one
+ * (yDimension[yDimension.length-1]) and till the current one.
+ */
+ i = yIndex.getIndexOfDifferences(itemYData, previousY);
+ for (k = headerLevels - 1; k >= i; k--) {
+ if (hasGroupTotal[k]) {
+ addColumnToColModel(1, k, iYData - 1); // add group total columns
+ }
+ }
+ previousY = itemYData;
+ addColumnToColModel(0, ylen - 1, iYData); // add standard column
+ }
+ // finalize of all totals
+ for (i = headerLevels - 1; i >= 0; i--) {
+ if (hasGroupTotal[i]) {
+ addColumnToColModel(1, i, yIndexLength - 1); // add the last group total columns
+ }
+ }
+ // add total columns calculated over all data of the row
+ if (isRowTotal) {
+ addColumnToColModel(2);
+ }
+
+ // ********************************
+ // The step 3: build column headers
+ // ********************************
+ // initialize colHeaders
+ previousY = yIndex.getItem(0);
+ for (k = 0; k < headerLevels; k++) {
+ colHeaders.push({
+ useColSpanStyle: o.useColSpanStyle,
+ groupHeaders: [{
+ titleText: ($.isFunction(yDimension[k].label) ?
+ yDimension[k].label.call(self, { yData: previousY[k], yIndex: previousY, yLevel: k, pivotOptions: o }) :
+ previousY[k]),
+ startColumnName: aggrlen === 1 ? "y0" : "y0a0",
+ numberOfColumns: aggrlen
+ }]
+ });
+ }
+ for (iYData = 1; iYData < yIndexLength; iYData++) {
+ itemYData = yIndex.getItem(iYData);
+ i = yIndex.getIndexOfDifferences(itemYData, previousY);
+ // We placed QNIQUE data in uniqueYData array.
+ // So we always find a difference on one level
+
+ addGroupTotalHeaders(iYData, i, previousY);
+ // add column headers which corresponds the main data
+ for (k = headerLevels - 1; k >= i; k--) {
+ colHeaders[k].groupHeaders.push({
+ titleText: ($.isFunction(yDimension[k].label) ?
+ yDimension[k].label.call(self, { yData: itemYData[k], yIndex: itemYData, yLevel: k, pivotOptions: o }) :
+ itemYData[k]),
+ startColumnName: "y" + iYData + (aggrlen === 1 ? "" : "a0"),
+ numberOfColumns: aggrlen
+ });
+ }
+ for (k = 0; k < i; k++) {
+ groupHeaders = colHeaders[k].groupHeaders;
+ groupHeaders[groupHeaders.length - 1].numberOfColumns += aggrlen;
+ }
+ previousY = itemYData;
+ }
+ addGroupTotalHeaders(yIndexLength, 0, previousY);
+
+ // fill groupHeaders without taking in consideration group total columns
+ if (isRowTotal) {
+ for (i = 0; i < headerLevels; i++) {
+ colHeaders[i].groupHeaders.push({
+ titleText: (i < headerLevels - 1 ? "" : o.totalHeader || ""),
+ startColumnName: "t" + (aggrlen === 1 ? "" : "a0"),
+ numberOfColumns: aggrlen
+ });
+ }
+ }
+
+ // *****************************
+ // The step 4: fill data of grid
+ // *****************************
+ xIndexLength = xIndex.getIndexLength();
+ for (iXData = 0; iXData < xIndexLength; iXData++) {
+ itemXData = xIndex.getItem(iXData);
+ pivotInfos = { iX: iXData, x: itemXData };
+ outputItem = { pivotInfos: pivotInfos }; // item of output data
+ // itemXData corresponds to the row of output data
+ for (i = 0; i < xlen; i++) {
+ // fill first columns of data
+ outputItem["x" + i] = itemXData[i];
+ }
+
+ indexesOfDataWithTheSameXValues = xIndex.getIndexesOfSourceData(iXData);
+ // The rows of input data with indexes from indexesOfDataWithTheSameXValues contains itemXData
+ // Now we build columns of itemXData row
+ if (isRowTotal) {
+ for (k = 0; k < aggrlen; k++) {
+ aggrContextTotalRows[k] = createTotalAggregation(k);
+ }
+ }
+ previousY = null;
+ initializeGroupTotals();
+ for (iYData = 0; iYData < yIndexLength; iYData++) {
+ itemYData = yIndex.getItem(iYData);
+ indexesOfDataWithTheSameYValues = yIndex.getIndexesOfSourceData(iYData);
+ // we calculate aggregate in every itemYData
+ for (k = 0; k < aggrlen; k++) {
+ if (previousY !== null) { // empty input data
+ finalizeGroupTotals(iYData - 1, itemYData, previousY, k);
+ }
+ iRows = [];
+ for (i = 0; i < indexesOfDataWithTheSameYValues.length; i++) {
+ iRowsY = indexesOfDataWithTheSameYValues[i];
+ if ($.inArray(iRowsY, indexesOfDataWithTheSameXValues) >= 0) {
+ iRows.push(iRowsY);
+ }
+ }
+ if (iRows.length > 0) {
+ // iRows array have all indexes of input data which have both itemXData and itemYData
+ // We need calculate aggregate agr over all the items
+ rows = new Array(iRows.length);
+ agr = aggregates[k];
+ aggrContext = new Aggregation(agr.aggregator, self, options);
+ for (iRow = 0; iRow < iRows.length; iRow++) {
+ i = iRows[iRow];
+ row = data[i];
+ rows[iRow] = row;
+ aggrContext.calc(row[agr.member], agr.member, row, i, data);
+ if (isRowTotal) {
+ aggrTotal = aggrContextTotalRows[k];
+ aggrTotal.calc(row[agr.member], agr.member, row, i, data);
+ gi = aggrTotal.groupInfo;
+ if ($.inArray(i, gi.iYs) < 0) {
+ gi.iYs.push(iYData);
+ gi.ys.push(itemYData);
+ }
+ if ($.inArray(i, gi.iRows) < 0) {
+ gi.iRows.push(i);
+ gi.rows.push(row);
+ }
+ }
+ calculateGroupTotals(itemYData, previousY, agr, k, row, i, iYData);
+ }
+ cmName = "y" + iYData + (aggrlen === 1 ? "" : "a" + k);
+ aggrContext.getResult(outputItem, cmName);
+ pivotInfos[cmName] = {
+ colType: 0, // standard row
+ iY: iYData,
+ y: itemYData,
+ iA: k,
+ a: agr,
+ iRows: iRows,
+ rows: rows
+ };
+ }
+ }
+ previousY = itemYData;
+ }
+ if (previousY !== null) { // if non-empty input data
+ for (k = 0; k < aggrlen; k++) {
+ finalizeGroupTotals(yIndexLength - 1, previousY, previousY, k);
+ }
+ }
+ if (isRowTotal) {
+ for (k = 0; k < aggrlen; k++) {
+ cmName = "t" + (aggrlen === 1 ? "" : "a" + k);
+ aggrTotal = aggrContextTotalRows[k];
+ aggrTotal.getResult(outputItem, cmName);
+ gi = aggrTotal.groupInfo;
+ pivotInfos[cmName] = {
+ colType: 2, // row total
+ iA: k,
+ a: aggregates[k],
+ iRows: gi.iRows,
+ rows: gi.rows,
+ iYs: gi.iYs,
+ ys: gi.ys
+ };
+ }
+ }
+ outputItems.push(outputItem);
+ }
+
+ // *****************************
+ // The step 5: fill total footer
+ // *****************************
+ if (o.footerTotals || o.colTotals) {
+ nRows = outputItems.length;
+ for (i = 0; i < xlen; i++) {
+ summaries["x" + i] = xDimension[i].footerText || "";
+ }
+ for (i = xlen; i < colModel.length; i++) {
+ cmName = colModel[i].name;
+ aggrContext = new Aggregation(o.footerAggregator || "sum", self, options);
+ for (iRow = 0; iRow < nRows; iRow++) {
+ outputItem = outputItems[iRow];
+ aggrContext.calc(outputItem[cmName], cmName, outputItem, iRow, outputItems);
+ }
+ aggrContext.getResult(summaries, cmName);
+ }
+ }
+
+ // return the final result.
+ options.colHeaders = colHeaders;
+ return {
+ colModel: colModel,
+ additionalProperties: additionalProperties,
+ options: options,
+ rows: outputItems,
+ groupOptions: groupOptions,
+ groupHeaders: colHeaders,
+ summary: summaries
+ };
+ },
+ jqPivot: function (data, pivotOpt, gridOpt, ajaxOpt) {
+ return this.each(function () {
+ var $t = this, $self = $($t), $j = $.fn.jqGrid;
+
+ function pivot() {
+ var pivotGrid = $j.pivotSetup.call($self, data, pivotOpt),
+ gHead = pivotGrid.groupHeaders,
+ assocArraySize = function (obj) {
+ // http://stackoverflow.com/a/6700/11236
+ var size = 0, key;
+ for (key in obj) {
+ if (obj.hasOwnProperty(key)) {
+ size++;
+ }
+ }
+ return size;
+ },
+ footerrow = assocArraySize(pivotGrid.summary) > 0 ? true : false,
+ groupingView = pivotGrid.groupOptions.groupingView,
+ query = jgrid.from.call($t, pivotGrid.rows), i;
+ if (!pivotOpt.skipSortByX) {
+ for (i = 0; i < groupingView.groupField.length; i++) {
+ query.orderBy(groupingView.groupField[i],
+ gridOpt != null && gridOpt.groupingView && gridOpt.groupingView.groupOrder != null && gridOpt.groupingView.groupOrder[i] === "desc" ? "d" : "a",
+ "text",
+ "");
+ }
+ }
+ pivotOpt.data = data;
+ $j.call($self, $.extend(true, {
+ datastr: $.extend(query.select(), footerrow ? { userdata: pivotGrid.summary } : {}),
+ datatype: "jsonstring",
+ footerrow: footerrow,
+ userDataOnFooter: footerrow,
+ colModel: pivotGrid.colModel,
+ additionalProperties: pivotGrid.additionalProperties,
+ pivotOptions: pivotGrid.options,
+ viewrecords: true,
+ sortname: pivotOpt.xDimension[0].dataName // ?????
+ }, pivotGrid.groupOptions, gridOpt || {}));
+ if (gHead.length) {
+ for (i = 0; i < gHead.length; i++) {
+ // Multiple calls of setGroupHeaders for one grid are wrong,
+ // but there are produces good results in case of usage
+ // useColSpanStyle: false option. The rowspan values
+ // needed be increased in case of usage useColSpanStyle: true
+ if (gHead[i] && gHead[i].groupHeaders.length) {
+ $j.setGroupHeaders.call($self, gHead[i]);
+ }
+ }
+ }
+ if (pivotOpt.frozenStaticCols) {
+ $j.setFrozenColumns.call($self);
+ }
+ }
+
+ if (typeof data === "string") {
+ $.ajax($.extend({
+ url: data,
+ dataType: "json",
+ success: function (data1) {
+ data = jgrid.getAccessor(data1, ajaxOpt && ajaxOpt.reader ? ajaxOpt.reader : "rows");
+ pivot();
+ }
+ }, ajaxOpt || {}));
+ } else {
+ pivot();
+ }
+ });
+ }
+ });
+ // end module grid.pivot
+
+ /**
+ * jqGrid extension for SubGrid Data
+ * Copyright (c) 2008-2014, Tony Tomov, tony@trirand.com
+ * Copyright (c) 2014-2017, Oleg Kiriljuk, oleg.kiriljuk@ok-soft-gmbh.com
+ * Dual licensed under the MIT and GPL licenses:
+ * http://www.opensource.org/licenses/mit-license.php
+ * http://www.gnu.org/licenses/gpl-2.0.html
+ **/
+ // begin module grid.subgrid
+ var subGridFeedback = function () {
+ var args = $.makeArray(arguments);
+ args[0] = "subGrid" + args[0].charAt(0).toUpperCase() + args[0].substring(1);
+ args.unshift("");
+ args.unshift("");
+ args.unshift(this.p);
+ return jgrid.feedback.apply(this, args);
+ },
+ collapseOrExpand = function (rowid, className) {
+ return this.each(function () {
+ if (this.grid && rowid != null && this.p.subGrid === true) {
+ var tr = $(this).jqGrid("getInd", rowid, true);
+ $(tr).find(">td." + className).trigger("click");
+ }
+ });
+ };
+ jgrid.extend({
+ setSubGrid: function () {
+ return this.each(function () {
+ var p = this.p, $self = $(this), cm = p.subGridModel[0], i,
+ getIcon = function (path) {
+ return $self.jqGrid("getIconRes", path);
+ };
+ p.subGridOptions = $.extend({
+ commonIconClass: getIcon("subgrid.common"),
+ plusicon: getIcon("subgrid.plus"),
+ minusicon: getIcon("subgrid.minus"),
+ openicon: (p.direction === "rtl" ? getIcon("subgrid.openRtl") : getIcon("subgrid.openLtr")),
+ expandOnLoad: false,
+ delayOnLoad: 50,
+ selectOnExpand: false,
+ selectOnCollapse: false,
+ reloadOnExpand: true
+ }, p.subGridOptions || {});
+ p.colNames.unshift("");
+ p.colModel.unshift({
+ name: "subgrid",
+ width: jgrid.cell_width ? p.subGridWidth + p.cellLayout : p.subGridWidth,
+ labelClasses: "jqgh_subgrid",
+ sortable: false,
+ resizable: false,
+ hidedlg: true,
+ search: false,
+ fixed: true,
+ frozen: true
+ });
+ if (cm) {
+ cm.align = $.extend([], cm.align || []);
+ for (i = 0; i < cm.name.length; i++) {
+ cm.align[i] = cm.align[i] || "left";
+ }
+ }
+ });
+ },
+ addSubGridCell: function (pos, iRow, rowid, item) {
+ var self = this[0], subGridOptions = self.p.subGridOptions,
+ hasSubgrid = $.isFunction(subGridOptions.hasSubgrid) ?
+ subGridOptions.hasSubgrid.call(self, { rowid: rowid, iRow: iRow, iCol: pos, data: item }) :
+ true;
+ return self.p == null ? "" :
+ "" +
+ (hasSubgrid ? "" : " ") +
+ " ";
+ },
+ addSubGrid: function (pos, sind) {
+ return this.each(function () {
+ var ts = this, p = ts.p, cm = p.subGridModel[0],
+ getSubgridStyle = function (name, calsses) {
+ return base.getGuiStyles.call(ts, "subgrid." + name, calsses || "");
+ },
+ thSubgridClasses = getSubgridStyle("thSubgrid", "ui-th-subgrid ui-th-column ui-th-" + p.direction),
+ rowSubTableClasses = getSubgridStyle("rowSubTable", "ui-subtblcell"),
+ rowClasses = getSubgridStyle("row", "ui-subgrid ui-row-" + p.direction),
+ tdWithIconClasses = getSubgridStyle("tdWithIcon", "subgrid-cell"),
+ tdDataClasses = getSubgridStyle("tdData", "subgrid-data"),
+ subGridCell = function ($tr, cell, pos1) {
+ var align = cm.align[pos1],
+ $td = $("").html(cell);
+ $tr.append($td);
+ },
+ fillXmlBody = function (data, $tbody) {
+ var sgmap = p.xmlReader.subgrid;
+ $(sgmap.root + " " + sgmap.row, data).each(function () {
+ var f, i, $tr = $("