Open-ILS/web/js/dojo/openils/widget/FlattenerGrid.js

   1 if (!dojo._hasResource["openils.widget.FlattenerGrid"]) {
   2     dojo.provide("openils.widget.FlattenerGrid");
   3
   4     dojo.require("DojoSRF");
   5     dojo.require("dojox.grid.DataGrid");
   6     dojo.require("openils.FlattenerStore");
   7     dojo.require("openils.PermaCrud");
   8     dojo.require("openils.widget.GridColumnPicker");
   9     dojo.require("openils.widget.EditDialog");  /* includes EditPane */
  10     dojo.require("openils.widget._GridHelperColumns");
  11
  12     dojo.declare(
  13         "openils.widget.FlattenerGrid",
  14         [dojox.grid.DataGrid, openils.widget._GridHelperColumns], {
  15             /* These potential constructor arguments are useful to
  16              * FlattenerGrid in their own right */
  17             "columnReordering": true,
  18             "columnPersistKey": null,
  19             "autoCoreFields": false,
  20             "autoCoreFieldsUnsorted": false,
  21             "autoCoreFieldsFilter": false,
  22             "autoFieldFields": null,
  23             "autoFieldFieldsUnsorted": null, /* array, subset of autoFieldFields */
  24             "showLoadFilter": false,    /* use FlattenerFilter(Dialog|Pane) */
  25             "filterAlwaysInDiv": null,  /* use FlattenerFilterPane and put its
  26                                            content in this HTML element */
  27             "fetchLock": false,
  28             "filterInitializers": null,
  29             "filterWidgetBuilders": null,
  30             "filterSemaphore": null,
  31             "filterSemaphoreCallback": null,
  32             "baseQuery": null,  /* Good place to mix in data from, say, context
  33                                    OU selectors so that it should get mixed
  34                                    correctly with the generated query from the
  35                                    filter dialog. */
  36             "savedFiltersInterface": null,
  37
  38             /* These potential constructor arguments may be useful to
  39              * FlattenerGrid in their own right, and are passed to
  40              * FlattenerStore. */
  41             "fmClass": null,
  42             "fmIdentifier": null,
  43             "mapExtras": null,
  44             "sortFieldReMap": null,
  45             "defaultSort": null,  /* whatever any part of the UI says will
  46                                      /replace/ this */
  47             "baseSort": null,     /* will contains what the columnpicker
  48                                      dictates, and precedes whatever the column
  49                                      headers provide. */
  50
  51             /* These potential constructor arguments are for functionality
  52              * copied from AutoGrid */
  53             "editOnEnter": false,       /* also implies edit-on-dblclick */
  54             "editStyle": "dialog",      /* "dialog" or "pane" */
  55             "requiredFields": null,     /* affects create/edit dialogs */
  56             "suppressEditFields": null, /* affects create/edit dialogs */
  57             "suppressFilterFields": null, /* affects filter dialog */
  58
  59             /* _generateMap() lives to interpret the attributes of the
  60              * FlattenerGrid dijit itself plus those definined in
  61              * <table>
  62              *  <thead>
  63              *   <tr>
  64              *    <th field="foo" ...>
  65              * to build the map to hand to the FlattenerStore, which in turn
  66              * uses it to query the flattener service.
  67              */
  68             "_generateMap": function() {
  69                 var map = this.mapClause = {};
  70                 var fields = this.structure[0].cells[0];
  71
  72                 /* These are the fields defined in thead -> tr -> [th,th,...].
  73                  * For purposes of building the map, where each field has
  74                  * three boolean attributes "display", "sort" and "filter",
  75                  * assume "display" is always true for these.
  76                  * That doesn't mean that at the UI level we can't hide a
  77                  * column later.
  78                  *
  79                  * If you need extra fields in the map for which display
  80                  * should *not* be true, use mapExtras.
  81                  */
  82                 dojo.forEach(
  83                     fields, function(field) {
  84                         if (field.field.match(/^\+/))
  85                             return; /* special fields e.g. checkbox/line # */
  86
  87                         map[field.field] = {
  88                             "display": true,
  89                             "filter": (field.ffilter || false),
  90                             "sort": field.fsort,
  91                             "path": field.fpath || field.field
  92                         };
  93                         /* The following attribute is not for the flattener
  94                          * service's benefit, but for other uses. We capture
  95                          * the hardcoded <th> value (the header label) if any.*/
  96                         if (field.name)
  97                             map[field.field]._label = field.name;
  98                     }
  99                 );
 100
 101                 if (this.mapExtras) {
 102                     /* It's not particularly useful to add simple fields, i.e.
 103                      *  circ_lib: "circ_lib.name"
 104                      * to mapExtras, because by convention used elsewhere in
 105                      * Flattener, that gives all attributes, including
 106                      * display, a true value. Still, be consistent to avoid
 107                      * stumping users.
 108                      */
 109                     for (var key in this.mapExtras) {
 110                         if (typeof this.mapExtras[key] != "object") {
 111                             this.mapExtras[key] = {
 112                                 "path": this.mapExtras[key],
 113                                 "sort": true,
 114                                 "filter": true,
 115                                 "display": true
 116                             };
 117                         }
 118                     }
 119                     dojo.mixin(map, this.mapExtras);
 120                 }
 121
 122                 /* Do this now, since we don't want a silently added
 123                  * identifier attribute in the terminii list (see its uses). */
 124                 this._calculateMapTerminii();
 125                 this._supplementHeaderNames();
 126
 127                 /* make sure we always have a field for fm identifier */
 128                 if (!map[this.fmIdentifier]) {
 129                     map[this.fmIdentifier] = {
 130                         "path": this.fmIdentifier,
 131                         "display": true,    /* Flattener displays it to us,
 132                                                but we don't display to user. */
 133                         "sort": false,
 134                         "filter": true
 135                     };
 136                 }
 137
 138                 return map;
 139             },
 140
 141             "_cleanMapForStore": function(map) {
 142                 var clean = dojo.clone(map);
 143
 144                 for (var column in clean) {
 145                     openils.Util.objectProperties(clean[column]).filter(
 146                         function(k) { return k.match(/^_/); }
 147                     ).forEach(
 148                         function(k) { delete clean[column][k]; }
 149                     );
 150                 }
 151
 152                 return clean;
 153             },
 154
 155             /* Given the hint of a class to start at, follow path to the end
 156              * and return information on the last field.  */
 157             "_followPathToEnd": function(hint, path, allow_selector_backoff) {
 158                 function _fm_is_selector_for_class(h, field) {
 159                     var cl = fieldmapper.IDL.fmclasses[h];
 160                     return (cl.field_map[cl.pkey].selector == field);
 161                 }
 162
 163                 var last_field, last_hint;
 164                 var orig_path = dojo.clone(path);
 165                 var field, field_def;
 166
 167                 while (field = path.shift()) {
 168                     /* XXX this assumes we have the whole IDL loaded. I
 169                      * guess we could teach this to work by loading classes
 170                      * on demand when we don't have the whole IDL loaded. */
 171                     field_def =
 172                         fieldmapper.IDL.fmclasses[hint].field_map[field];
 173
 174                     if (!field_def) {
 175                         /* This can be ok in some cases. Columns following
 176                          * IDL paths involving links with a nonempty "map"
 177                          * attribute can be used for display only (no
 178                          * sort, no filter). */
 179                         console.info(
 180                             "Lost our way in IDL at hint " + hint +
 181                             ", field " + field + "; may be ok"
 182                         );
 183                         return null;
 184                     }
 185
 186                     if (field_def["class"]) {
 187                         last_field = field;
 188                         last_hint = hint;
 189
 190                         hint = field_def["class"];
 191                     } else if (path.length) {
 192                         /* There are more fields left but we can't follow
 193                          * the chain via IDL any further. */
 194                         throw new Error(
 195                             "_calculateMapTerminii can't parse path " +
 196                             orig_path + " (at " + field + ")"
 197                         );
 198                     }
 199                 }
 200
 201                 var datatype = field_def.datatype;
 202                 var indirect = false;
 203                 /* If allowed, back off the last field in the path if it's a
 204                  * selector for its class, because the preceding field will be
 205                  * a better thing to hand to AutoFieldWidget.
 206                  */
 207                 if (orig_path.length > 1 && allow_selector_backoff &&
 208                         _fm_is_selector_for_class(hint, field_def.name)) {
 209                     hint = last_hint;
 210                     field = last_field;
 211                     datatype = "link";
 212                     indirect = true;
 213                 } else {
 214                     field = field_def.name;
 215                 }
 216
 217                 return {
 218                     "fmClass": hint,
 219                     "name": field,
 220                     "label": field_def.label,
 221                     "datatype": datatype,
 222                     "indirect": indirect
 223                 };
 224             },
 225
 226             /* The FlattenerStore doesn't need this, but it has at least two
 227              * uses: 1) FlattenerFilterDialog, 2) setting column header labels
 228              * to IDL defaults.
 229              *
 230              * To call these 'Terminii' can be misleading. In certain
 231              * (actually probably common) cases, they won't really be the last
 232              * field in a path, but the next-to-last. Read on. */
 233             "_calculateMapTerminii": function() {
 234                 this.mapTerminii = [];
 235                 for (var column in this.mapClause) {
 236                     var end = this._followPathToEnd(
 237                         this.fmClass,
 238                         this.mapClause[column].path.split(/\./),
 239                         true /* allow selector backoff */
 240                     );
 241                     if (!end)
 242                         continue;
 243                     var terminus = dojo.mixin(
 244                         end, {
 245                             "simple_name": column,
 246                             "isfilter": this.mapClause[column].filter
 247                         }
 248                     );
 249                     if (this.mapClause[column]._label)
 250                         terminus.label = this.mapClause[column]._label;
 251
 252                     this.mapTerminii.push(terminus);
 253                 }
 254             },
 255
 256             "_supplementHeaderNames": function() {
 257                 /* If we didn't give a particular header cell
 258                  * (<th>) a display name (the innerHTML of that <th>), then
 259                  * use the IDL to provide the label of the terminus of the
 260                  * flattener path for that column. It may be better than using
 261                  * the raw field name. */
 262                 var self = this;
 263                 this.structure[0].cells[0].forEach(
 264                     function(header) {
 265                         if (!header.name) {
 266                             header.name = self.mapTerminii.filter(
 267                                 function(t) {
 268                                     return t.simple_name == header.field;
 269                                 }
 270                             )[0].label;
 271                         }
 272                     }
 273                 );
 274             },
 275
 276             "_columnOrderingAndLabels": function() {
 277                 var labels = [];
 278                 var columns = [];
 279
 280                 this.views.views[0].structure.cells[0].forEach(
 281                     function(c) {
 282                         if (!c.field.match(/^\+/)) {
 283                             labels.push(c.name);
 284                             columns.push(c.field);
 285                         }
 286                     }
 287                 );
 288
 289                 return {"labels": labels, "columns": columns};
 290             },
 291
 292             "_getAutoFieldFields": function(fmclass, path) {
 293                 var field_list = dojo.clone(
 294                     fieldmapper.IDL.fmclasses[fmclass].fields)
 295                 .filter(
 296                     function(f) { return !f.virtual && f.datatype != "link"; }
 297                 );
 298
 299                 /* Sort fields unless the path is named in grid property
 300                  * 'autoFieldFieldsUnsorted' (array). */
 301                 if (!dojo.isArray(this.autoFieldFieldsUnsorted) ||
 302                         this.autoFieldFieldsUnsorted.indexOf(path) == -1) {
 303                     field_list = field_list.sort(
 304                         function(a, b) { return a.label > b.label ? 1 : -1; }
 305                     );
 306                 }
 307
 308                 return field_list;
 309             },
 310
 311             /* Take our core class (this.fmClass) and add table columns for
 312              * any field we don't already have covered by actual hard-coded
 313              * <th> columns. */
 314             "_addAutoCoreFields": function() {
 315                 var cell_list = this.structure[0].cells[0];
 316                 var fields = dojo.clone(
 317                     fieldmapper.IDL.fmclasses[this.fmClass].fields
 318                 );
 319
 320                 if (!this.autoCoreFieldsUnsorted) {
 321                     fields = fields.sort(
 322                         function(a, b) { return a.label > b.label ? 1 : -1; }
 323                     );
 324                 }
 325
 326                 dojo.forEach(
 327                     fields, dojo.hitch(this, function(f) {
 328                         if (f.datatype == "link" || f.virtual)
 329                             return;
 330
 331                         if (cell_list.filter(
 332                             function(c) {
 333                                 if (!c.fpath) return false;
 334                                 return c.fpath.split(/\./)[0] == f.name;
 335                             }
 336                         ).length)
 337                             return;
 338
 339                         cell_list.push({
 340                             "field": f.name,
 341                             "name": f.label,
 342                             "fsort": true,
 343                             "ffilter": this.autoCoreFieldsFilter
 344                         });
 345                     })
 346                 );
 347             },
 348
 349             "_addAutoFieldFields": function(paths) {
 350                 var self = this;
 351                 var n = 0;
 352
 353                 dojo.forEach(
 354                     paths, function(path) {
 355                         /* The beginning is the end. */
 356                         var beginning = self._followPathToEnd(
 357                             self.fmClass, path.split(/\./), false
 358                         );
 359                         if (!beginning) {
 360                             return;
 361                         } else {
 362                             dojo.forEach(
 363                                 self._getAutoFieldFields(
 364                                     beginning.fmClass, path
 365                                 ),
 366                                 function(field) {
 367                                     var would_be_path =
 368                                         path + "." + field.name;
 369                                     var wbp_re =
 370                                         new RegExp("^" + would_be_path);
 371                                     if (!self.structure[0].cells[0].filter(
 372                                         function(c) {
 373                                             return c.fpath &&
 374                                                 c.fpath.match(wbp_re);
 375                                         }
 376                                     ).length) {
 377                                         self.structure[0].cells[0].push({
 378                                             "field": "AUTO_" + beginning.name +
 379                                                 "_" + field.name,
 380                                             "name": beginning.label + " - " +
 381                                                 field.label,
 382                                             "fsort": true,
 383                                             "fpath": would_be_path,
 384                                             "_visible": false
 385                                         });
 386                                     }
 387                                 }
 388                             );
 389                         }
 390                     }
 391                 );
 392             },
 393
 394             "_addAutoFields": function() {
 395                 if (this.autoCoreFields)
 396                     this._addAutoCoreFields();
 397
 398                 if (dojo.isArray(this.autoFieldFields))
 399                     this._addAutoFieldFields(this.autoFieldFields);
 400
 401                 this.setStructure(this.structure);
 402             },
 403
 404             "constructor": function(args) {
 405                 dojo.mixin(this, args);
 406
 407                 this.fmIdentifier = this.fmIdentifier ||
 408                     fieldmapper.IDL.fmclasses[this.fmClass].pkey;
 409
 410                 this.overrideEditWidgets = {};
 411                 this.overrideEditWidgetClass = {};
 412                 this.overrideWidgetArgs = {};
 413             },
 414
 415             "startup": function() {
 416                 /* Save original query for further filtering later, unless
 417                  * we've already defined baseQuery from the outside, in
 418                  * which case it persists. */
 419                 if (!this.baseQuery)
 420                     this.baseQuery = dojo.clone(this.query);
 421
 422                 this._addAutoFields();
 423
 424                 this._startupGridHelperColumns();
 425
 426                 this._generateMap();
 427
 428                 if (!this.columnPicker) {
 429                     this.columnPicker =
 430                         new openils.widget.GridColumnPicker(
 431                             null, this.columnPersistKey, this);
 432                     this.columnPicker.onLoad = dojo.hitch(
 433                         this, function(opts) { this._finishStartup(opts.sortFields) });
 434
 435                     this.columnPicker.onSortChange = dojo.hitch(this,
 436                         /* directly after, this.update() is called by the
 437                            column picker, causing a re-fetch */
 438                         function(fields) {
 439                             this.store.baseSort = this._mapCPSortFields(fields)
 440                         }
 441                     );
 442
 443                     this.columnPicker.load();
 444                 }
 445
 446                 this.inherited(arguments);
 447             },
 448
 449             "canSort": function(idx, skip_structure /* API abuse */) {
 450                 var initial = this.inherited(arguments);
 451
 452                 /* idx is one-based instead of zero-based for a reason. */
 453                 var view_idx = Math.abs(idx) - 1;
 454                 return initial && (
 455                     skip_structure ||
 456                         this.views.views[0].structure.cells[0][view_idx].fsort
 457                 );
 458             },
 459
 460             /*  Maps ColumnPicker sort fields to the correct format.
 461                 If no sort fields specified, falls back to defaultSort */
 462             "_mapCPSortFields": function(sortFields) {
 463                 var sort = this.defaultSort;
 464                 if (sortFields.length) {
 465                     sort = sortFields.map(function(f) {
 466                         a = {};
 467                         a[f.field] = f.direction;
 468                         return a;
 469                     });
 470                 }
 471                 return sort;
 472             },
 473
 474             "_finishStartup": function(sortFields) {
 475
 476                 this._setStore( /* Seriously, let's leave this as _setStore. */
 477                     new openils.FlattenerStore({
 478                         "fmClass": this.fmClass,
 479                         "fmIdentifier": this.fmIdentifier,
 480                         "mapClause": this._cleanMapForStore(this.mapClause),
 481                         "baseSort": this.baseSort,
 482                         "defaultSort": this._mapCPSortFields(sortFields),
 483                         "sortFieldReMap": this.sortFieldReMap
 484
 485                     }), this.query
 486                 );
 487
 488                 // pick up any column label changes
 489                 this.columnPicker.reloadStructure();
 490
 491                 if (!this.fetchLock)
 492                     this._refresh(true);
 493
 494                 this._showing_create_pane = false;
 495
 496                 if (this.editOnEnter)
 497                     this._applyEditOnEnter();
 498                 else if (this.singleEditStyle)
 499                     this._applySingleEditStyle();
 500
 501                 /* Like AutoGrid's paginator, but we'll never have Back/Next
 502                  * links.  Just a place to hold misc links */
 503                 this._setupLinks();
 504             },
 505
 506
 507             "_setupLinks": function() {
 508                 this.linkHolder = new dijit.layout.ContentPane();
 509                 dojo.place(this.linkHolder.domNode, this.domNode, "before");
 510
 511                 if (this.showLoadFilter) {
 512                     var which_filter_ui = this.filterAlwaysInDiv ?
 513                         "FlattenerFilterPane" : "FlattenerFilterDialog";
 514
 515                     dojo.require("openils.widget." + which_filter_ui);
 516                     this.filterUi =
 517                         new openils.widget[which_filter_ui]({
 518                             "fmClass": this.fmClass,
 519                             "mapTerminii": this.mapTerminii,
 520                             "useDiv": this.filterAlwaysInDiv,
 521                             "initializers": this.filterInitializers,
 522                             "widgetBuilders": this.filterWidgetBuilders,
 523                             "suppressFilterFields": this.suppressFilterFields,
 524                             "savedFiltersInterface": this.savedFiltersInterface
 525                         });
 526
 527                     this.filterUi.onApply = dojo.hitch(
 528                         this, function(filter) {
 529                             this.filter(
 530                                 dojo.mixin(filter, this.baseQuery),
 531                                 true    /* re-render */
 532                             );
 533                         }
 534                     );
 535
 536                     this.filterUi.startup();
 537
 538                     if (this.filterSemaphore && this.filterSemaphore()) {
 539                         if (this.filterSemaphoreCallback)
 540                             this.filterSemaphoreCallback();
 541                     }
 542                     if (!this.filterAlwaysInDiv) {
 543                         dojo.create(
 544                             "a", {
 545                                 "innerHTML": "Filter",  /* XXX i18n */
 546                                 "href": "javascript:void(0);",
 547                                 "onclick": dojo.hitch(this, function() {
 548                                     this.filterUi.show();
 549                                 })
 550                             }, this.linkHolder.domNode
 551                         );
 552                     }
 553                 }
 554             },
 555
 556             "refresh": function() {
 557                 this.fetchLock = false;
 558                 this._refresh(/* isRender */ true);
 559             },
 560
 561             "_fetch": function() {
 562                 if (this.fetchLock)
 563                     return;
 564                 else
 565                     return this.inherited(arguments);
 566             },
 567
 568             /* ******** below are methods mostly copied but
 569              * slightly changed from AutoGrid ******** */
 570
 571             "_applySingleEditStyle": function() {
 572                 this.onMouseOverRow = function(e) {};
 573                 this.onMouseOutRow = function(e) {};
 574                 this.onCellFocus = function(cell, rowIndex) {
 575                     this.selection.deselectAll();
 576                     this.selection.select(this.focus.rowIndex);
 577                 };
 578             },
 579
 580             /* capture keydown and launch edit dialog on enter */
 581             "_applyEditOnEnter": function() {
 582                 this._applySingleEditStyle();
 583
 584                 dojo.connect(
 585                     this, "onRowDblClick", function(e) {
 586                         if (this.editStyle == "pane")
 587                             this._drawEditPane(
 588                                 this.selection.getFirstSelected(),
 589                                 this.focus.rowIndex
 590                             );
 591                         else
 592                             this._drawEditDialog(
 593                                 this.selection.getFirstSelected(),
 594                                 this.focus.rowIndex
 595                             );
 596                     }
 597                 );
 598
 599                 dojo.connect(
 600                     this, "onKeyDown", function(e) {
 601                         if (e.keyCode == dojo.keys.ENTER) {
 602                             this.selection.deselectAll();
 603                             this.selection.select(this.focus.rowIndex);
 604                             if (this.editStyle == "pane")
 605                                 this._drawEditPane(
 606                                     this.selection.getFirstSelected(),
 607                                     this.focus.rowIndex
 608                                 );
 609                             else
 610                                 this._drawEditDialog(
 611                                     this.selection.getFirstSelected(),
 612                                     this.focus.rowIndex
 613                                 );
 614                         }
 615                     }
 616                 );
 617             },
 618
 619             "_makeEditPane": function(storeItem, rowIndex, onPostSubmit, onCancel) {
 620                 var grid = this;
 621                 var fmObject = (new openils.PermaCrud()).retrieve(
 622                     this.fmClass,
 623                     this.store.getIdentity(storeItem)
 624                 );
 625
 626                 var pane = new openils.widget.EditPane({
 627                     "fmObject": fmObject,
 628                     "hideSaveButton": this.editReadOnly,
 629                     "readOnly": this.editReadOnly,
 630                     "overrideWidgets": this.overrideEditWidgets,
 631                     "overrideWidgetClass": this.overrideEditWidgetClass,
 632                     "overrideWidgetArgs": this.overrideWidgetArgs,
 633                     "disableWidgetTest": this.disableWidgetTest,
 634                     "requiredFields": this.requiredFields,
 635                     "suppressFields": this.suppressEditFields,
 636                     "onPostSubmit": function() {
 637                         /* ask the store to call flattener specially to get
 638                          * the flat row related to only this fmobj */
 639                         grid.store.loadItem({"force": true, "item": storeItem});
 640
 641                         if (grid.onPostUpdate)
 642                             grid.onPostUpdate(storeItem, rowIndex);
 643
 644                         setTimeout(
 645                             function() {
 646                                 try {
 647                                     grid.views.views[0].getCellNode(
 648                                         rowIndex, 0
 649                                     ).focus();
 650                                 } catch (E) { }
 651                             }, 200
 652                         );
 653                         if (onPostSubmit)
 654                             onPostSubmit();
 655                     },
 656                     "onCancel": function() {
 657                         setTimeout(
 658                             function() {
 659                                 grid.views.views[0].getCellNode(
 660                                     rowIndex, 0
 661                                 ).focus();
 662                             }, 200
 663                         );
 664                         if (onCancel)
 665                             onCancel();
 666                     }
 667                 });
 668
 669                 if (typeof this.editPaneOnSubmit == "function")
 670                     pane.onSubmit = this.editPaneOnSubmit;
 671
 672                 pane.fieldOrder = this.fieldOrder;
 673                 pane.mode = "update";
 674                 return pane;
 675             },
 676
 677             "_makeCreatePane": function(onPostSubmit, onCancel) {
 678                 var grid = this;
 679                 var pane = new openils.widget.EditPane({
 680                     "fmClass": this.fmClass,
 681                     "overrideWidgets": this.overrideEditWidgets,
 682                     "overrideWidgetClass": this.overrideEditWidgetClass,
 683                     "overrideWidgetArgs": this.overrideWidgetArgs,
 684                     "disableWidgetTest": this.disableWidgetTest,
 685                     "requiredFields": this.requiredFields,
 686                     "suppressFields": this.suppressEditFields,
 687                     "onPostSubmit": function(req, cudResults) {
 688                         var fmObject = cudResults[0];
 689                         if (grid.onPostCreate)
 690                             grid.onPostCreate(fmObject);
 691                         if (fmObject) {
 692                             grid.store.fetchItemByIdentity({
 693                                 "identity": fmObject[grid.fmIdentifier](),
 694                                 "onItem": function(item) {
 695                                     grid.store.onNew(item);
 696                                 }
 697                             });
 698                         }
 699
 700                         setTimeout(
 701                             function() {
 702                                 try {
 703                                     grid.selection.select(grid.rowCount - 1);
 704                                     grid.views.views[0].getCellNode(
 705                                         grid.rowCount - 1, 1
 706                                     ).focus();
 707                                 } catch (E) { }
 708                             }, 200
 709                         );
 710
 711                         if (onPostSubmit)
 712                             onPostSubmit(fmObject);
 713                     },
 714                     "onCancel": function() { if (onCancel) onCancel(); }
 715                 });
 716
 717                 if (typeof this.createPaneOnSubmit == "function")
 718                     pane.onSubmit = this.createPaneOnSubmit;
 719                 pane.fieldOrder = this.fieldOrder;
 720                 pane.mode = "create";
 721                 return pane;
 722             },
 723
 724             /**
 725              * Creates an EditPane with a copy of the data from the provided store
 726              * item for cloning said item
 727              * @param {Object} storeItem Dojo data item
 728              * @param {Number} rowIndex The Grid row index of the item to be cloned
 729              * @param {Function} onPostSubmit Optional callback for post-submit behavior
 730              * @param {Function} onCancel Optional callback for clone cancelation
 731              * @return {Object} The clone EditPane
 732              */
 733             "_makeClonePane": function(storeItem,rowIndex,onPostSubmit,onCancel) {
 734                 var clonePane = this._makeCreatePane(onPostSubmit, onCancel);
 735                 var origPane = this._makeEditPane(storeItem, rowIndex);
 736                 clonePane.startup();
 737                 origPane.startup();
 738                 dojo.forEach(
 739                     origPane.fieldList, function(field) {
 740                         if (field.widget.widget.attr('disabled'))
 741                             return;
 742
 743                         var w = clonePane.fieldList.filter(
 744                             function(i) { return (i.name == field.name) }
 745                         )[0];
 746
 747                         // sync widgets
 748                         w.widget.baseWidgetValue(field.widget.widget.attr('value'));
 749
 750                         // async widgets
 751                         w.widget.onload = function() {
 752                             w.widget.baseWidgetValue(
 753                                 field.widget.widget.attr('value')
 754                             )
 755                         };
 756                     }
 757                 );
 758                 origPane.destroy();
 759                 return clonePane;
 760             },
 761
 762
 763             "_drawEditDialog": function(storeItem, rowIndex) {
 764                 var done = dojo.hitch(this, function() { this.hideDialog(); });
 765                 var pane = this._makeEditPane(storeItem, rowIndex, done, done);
 766                 this.editDialog = new openils.widget.EditDialog({editPane:pane});
 767                 this.editDialog.startup();
 768                 this.editDialog.show();
 769             },
 770
 771             /**
 772              * Generates an EditDialog for object creation and displays it to the user
 773              */
 774             "showCreateDialog": function() {
 775                 var done = dojo.hitch(this, function() { this.hideDialog(); });
 776                 var pane = this._makeCreatePane(done, done);
 777                 this.editDialog = new openils.widget.EditDialog({editPane:pane});
 778                 this.editDialog.startup();
 779                 this.editDialog.show();
 780             },
 781
 782             "_drawEditPane": function(storeItem, rowIndex) {
 783                 var done = dojo.hitch(this, function() { this.hidePane(); });
 784
 785                 dojo.style(this.domNode, "display", "none");
 786
 787                 this.editPane = this._makeEditPane(storeItem, rowIndex, done, done);
 788                 this.editPane.startup();
 789                 dojo.place(this.editPane.domNode, this.domNode, "before");
 790
 791                 if (this.onEditPane)
 792                     this.onEditPane(this.editPane);
 793             },
 794
 795             "showClonePane": function(onPostSubmit) {
 796                 var done = dojo.hitch(this, function() { this.hidePane(); });
 797                 var row = this.getFirstSelectedRow();
 798
 799                 if (!row)
 800                     return;
 801
 802                 if (onPostSubmit) {
 803                     postSubmit = dojo.hitch(
 804                         this, function(result) {
 805                             onPostSubmit(this.getItem(row), result);
 806                             this.hidePane();
 807                         }
 808                     );
 809                 } else {
 810                     postSubmit = done;
 811                 }
 812
 813                 dojo.style(this.domNode, "display", "none");
 814                 this.editPane = this._makeClonePane(
 815                     this.getItem(row), row, postSubmit, done
 816                 );
 817                 dojo.place(this.editPane.domNode, this.domNode, "before");
 818                 if (this.onEditPane)
 819                     this.onEditPane(this.editPane);
 820             },
 821
 822             "showCreatePane": function() {
 823                 if (this._showing_create_pane)
 824                     return;
 825                 this._showing_create_pane = true;
 826
 827                 var done = dojo.hitch(
 828                     this, function() {
 829                         this._showing_create_pane = false;
 830                         this.hidePane();
 831                     }
 832                 );
 833
 834                 dojo.style(this.domNode, "display", "none");
 835
 836                 this.editPane = this._makeCreatePane(done, done);
 837                 this.editPane.startup();
 838
 839                 dojo.place(this.editPane.domNode, this.domNode, "before");
 840
 841                 if (this.onEditPane)
 842                     this.onEditPane(this.editPane);
 843             },
 844
 845             "hideDialog": function() {
 846                 this.editDialog.hide();
 847                 this.editDialog.destroy();
 848                 delete this.editDialog;
 849                 this.update();
 850             },
 851
 852             "hidePane": function() {
 853                 this.domNode.parentNode.removeChild(this.editPane.domNode);
 854                 this.editPane.destroy();
 855                 delete this.editPane;
 856                 dojo.style(this.domNode, "display", "block");
 857                 this.update();
 858             },
 859
 860             "deleteSelected": function() {
 861                 var self = this;
 862
 863                 this.getSelectedItems().forEach(
 864                     function(item) {
 865                         var fmobj = new fieldmapper[self.fmClass]();
 866                         fmobj[self.fmIdentifier](
 867                             self.store.getIdentity(item)
 868                         );
 869                         (new openils.PermaCrud()).eliminate(
 870                             fmobj, {
 871                                 "oncomplete": function() {
 872                                     self.store.deleteItem(item);
 873                                 }
 874                             }
 875                         );
 876                     }
 877                 );
 878             },
 879
 880             "getSelectedIDs": function() {
 881                 return this.getSelectedItems().map(
 882                     dojo.hitch(
 883                         this,
 884                         function(item) { return this.store.getIdentity(item); }
 885                     )
 886                 );
 887             },
 888
 889             /* Return true if every row known to the grid is selected. Code
 890              * that calls this function will do so when it thinks the user
 891              * might actually mean "select everything this grid could show"
 892              * even though we don't necessarily know (and the user hasn't
 893              * necessarily noticed) whether the grid has been scrolled as far
 894              * down as possible and all the possible results have been
 895              * fetched by the grid's store. */
 896             "everythingSeemsSelected": function() {
 897                 return dojo.query(
 898                     "[name=autogrid.selector]", this.domNode
 899                 ).filter(
 900                     function(c) { return (!c.disabled && !c.checked) }
 901                 ).length == 0;
 902             },
 903
 904             /* Print the same data that the Flattener is feeding to the
 905              * grid, sorted the same way too. Remove limit and offset (i.e.,
 906              * print it all) unless those are passed in to the print() method.
 907              */
 908             "print": function(limit, offset, query_mixin) {
 909                 var coal = this._columnOrderingAndLabels();
 910                 var req = {
 911                     "query": dojo.mixin({}, this.query, query_mixin),
 912                     "queryOptions": {
 913                         "columns": coal.columns,
 914                         "labels": coal.labels
 915                     },
 916                     "onComplete": function(text) {
 917                         openils.Util.printHtmlString(text);
 918                     }
 919                 };
 920
 921                 if (limit) {
 922                     req.count = limit;
 923                     req.start = offset || 0;
 924                 } else {
 925                     req.queryOptions.all = true;
 926                 }
 927
 928                 this.store.fetchToPrint(req);
 929             },
 930
 931             "printSelected": function() {
 932                 var id_blob = {};
 933                 id_blob[this.store.getIdentityAttributes()[0]] =
 934                     this.getSelectedIDs();
 935
 936                 this.print(null, null, id_blob);
 937             },
 938
 939             "setBaseQuery": function(query) {   /* sets a persistent query
 940                                                    that always gets mixed in
 941                                                    with whatever you do in the
 942                                                    filter dialog */
 943                 this._baseQuery = dojo.clone(this.query = query);
 944             }
 945         }
 946     );
 947
 948     /* monkey patch so we can get more attributes from each column in the
 949      * markup that specifies grid columns (table->thead->tr->[td,...])
 950      */
 951     (function() {
 952         var b = dojox.grid.cells._Base;
 953         var orig_mf = b.markupFactory;
 954
 955         b.markupFactory = function(node, cellDef) {
 956             orig_mf(node, cellDef);
 957
 958             dojo.forEach(
 959                 ["fpath", "ffilter"], function(a) {
 960                     var value = dojo.attr(node, a);
 961                     if (value)
 962                         cellDef[a] = value;
 963                 }
 964             );
 965
 966             /* fsort and _visible are different. Assume true unless defined. */
 967             dojo.forEach(
 968                 ["fsort", "_visible"], function(a) {
 969                     var val = dojo.attr(node, a);
 970                     cellDef[a] = (typeof val == "undefined" || val === null) ?
 971                         true : dojo.fromJson(val);
 972                 }
 973             );
 974         };
 975     })();
 976
 977     /* the secret to successfully subclassing dojox.grid.DataGrid */
 978     openils.widget.FlattenerGrid.markupFactory =
 979         dojox.grid.DataGrid.markupFactory;
 980 }