Changeset 17

Timestamp:

08/30/08 18:54:41 (4 years ago)

Author:

tsuckowhomberg

Message:

• fixed: (BufferedStore?.js) store would not allow for adding records without throwing errors when the store was initialized with no records; changed bufferRange to be initialized with [0,0] instead of [0, bufferSize] and incremented bufferRange-count according to the records coming in, until bufferRange[1] equals to bufferSize
• fixed: (BufferedGridView?.js, BufferedRowSelectionModel?.js) store "add" event would neccessarily trigger the selectionmodel's onAdd-listener before the onAdd-listener of the GridView?, resulting in false rendering of selected records; changed the selection model to listen to the "rowsinserted" event of the view and extended this event to pass the length of added record as the fourth parameter to all it's listeners
• fixed: (BufferedGridView?.js) collapsed panel would hide added records of the grid when the grid is expanded again and would lose scroll-position; added listener for "expand"-event of the view's gridpanel to recalculate visible rows, the buffer inset and reset the scrollbar's position to the proper value
• enhancement: (BufferedGridView?.js) improved calculation of rows that would cause spill when new records get added in "insertRows()"
• fixed: (BufferedGridView?.js) when adding new rows, selected rows which change their position in the view would lose their css-style for indicating that they are selected and pass it to unselected rows; updated "processRows()" to remove css-styles on rows which are currently not selected
• fixed: (BufferedGridView?.js) "onAdd()" would not always insert records depending on the position they got added in the store; updated and improved code based on "rows get added before first visible row", "rows get added after the last visible row", "rows get added somewhere in between the first and last visible row"

Location:

trunk

Files:

• CHANGELOG (modified) (1 diff)
• src/BufferedGridView.js (modified) (15 diffs)
• src/BufferedRowSelectionModel.js (modified) (4 diffs)
• src/BufferedStore.js (modified) (2 diffs)

trunk/CHANGELOG

@@ -1 @@
-Version 0.2rc3
+Version 0.2rc4
 30-August-2008
 
-- fixes;
+- fixes:
+ - BufferedStore.js: store would not allow for adding records without throwing errors when
+the store was initialized with no records; changed bufferRange to be initialized with [0,0]
+instead of [0, bufferSize] and incremented bufferRange-count according to the records coming
+in, until bufferRange[1] equals to bufferSize
+ - BufferedGridView.js, BufferedRowSelectionModel.js: store "add" event would neccessarily
+trigger the selectionmodel's onAdd-listener before the onAdd-listener of the GridView, resulting
+in false rendering of selected records; changed the selection model to listen to the "rowsinserted"
+event of the view and extended this event to pass the length of added record as the fourth
+parameter to all it's listeners
+ - BufferedGridView.js: collapsed panel would hide added records of the grid when the grid is
+expanded again and would lose scroll-position; added listener for "expand"-event of the view's
+gridpanel to recalculate visible rows, the buffer inset and reset the scrollbar's position to the
+proper value
+ - BufferedGridView.js: "onAdd()" would not always insert records depending on the position they got
+added in the store; updated and improved code based on "rows get added before first visible row",
+"rows get added after the last visible row", "rows get added somewhere in between the first and last visible row"
+- enhancements:
+ - BufferedGridView.js: improved calculation of rows that would cause spill when new records
+get added in "insertRows()"
+
+
+Version 0.2rc3
+30-August-2008
+
+- fixes:
  - BufferedGridView.js: last row would not always be rendered proper if the end of
 records is reached and the panel would be resized so that more records are displayable

trunk/src/BufferedGridView.js

@@ -337 +337 @@
         Ext.ux.grid.BufferedGridView.superclass.init.call(this, grid);
 
+        grid.on('expand', this._onExpand, this);
+
         this.ds.on('beforeload', this.onBeforeLoad, this);
         },
@@ -463 +465 @@
 // {{{ ----------------------dom/mouse listeners--------------------------------
 
+    /**
+     * Tells the view to recalculate the number of rows displayable
+     * and the buffer inset, when it gets expanded after it has been
+     * collapsed.
+     *
+     */
+    _onExpand : function(panel)
+    {
+        this.adjustVisibleRows();
+        this.adjustBufferInset();
+        this.adjustScrollerPos(this.rowHeight*this.rowIndex, true);
+    },
+
     // private
     onColumnMove : function(cm, oldIndex, newIndex)
@@ -766 +781 @@
                 this.adjustScrollerPos(this.rowHeight*recordLen, true);
 
-                this.fireEvent("rowsinserted", this, index, index);
+                this.fireEvent("rowsinserted", this, index, index, recordLen);
                 this.processRows();
                 // the cursor did virtually move
@@ -777 +792 @@
 
             this.adjustBufferInset();
-            this.fireEvent("rowsinserted", this, index, index);
+            this.fireEvent("rowsinserted", this, index, index, recordLen);
             return;
         }
@@ -790 +805 @@
 
         // rows would be added at the end of the rows which are currently
-        // displayed, so fire the evnt and return
-        if (index >= (this.rowIndex-this.ds.bufferRange[0])+len && len == this.visibleRows) {
+        // displayed, so fire the event, resize buffer and adjust visible
+        // rows and return
+        if (start > this.rowIndex+(this.visibleRows-1)) {
             this.fireEvent("beforerowsinserted", this, start, end);
-            this.fireEvent("rowsinserted", this, start, end);
+            this.fireEvent("rowsinserted",       this, start, end, recordLen);
 
             this.adjustVisibleRows();
@@ -800 +816 @@
         }
 
-        // we are all up in the grid, first row is first record,
-        // prepend!
-        else if (index == 0 && this.rowIndex == 0) {
+        // rows get added somewhere in the current view.
+        else if (start >= this.rowIndex && start <= this.rowIndex+(this.visibleRows-1)) {
             firstRow = index;
-            lastRow  = Math.min(end, this.rowIndex+this.visibleRows-1) - this.ds.bufferRange[0];
+            // compute the last row that would be affected of an insert operation
+            lastRow  = index+(recordLen-1);
             this.lastRowIndex  = this.rowIndex;
-            this.rowIndex      = 0;
+            this.rowIndex      = (start > this.rowIndex) ? this.rowIndex : start;
+
             this.insertRows(ds, firstRow, lastRow);
+
+            if (this.lastRowIndex != this.rowIndex) {
+                this.fireEvent('cursormove', this, this.rowIndex,
+                               Math.min(this.ds.totalLength, this.visibleRows-this.rowClipped),
+                               this.ds.totalLength);
+            }
 
             this.adjustVisibleRows();
@@ -813 +836 @@
         }
 
-        // rows get added before the first row in the view
-        else if (len == this.visibleRows && index <= this.rowIndex-this.ds.bufferRange[0]) {
-
+        // rows get added before the first visible row, which would not affect any
+        // rows to be re-rendered
+        else if (start < this.rowIndex) {
             this.fireEvent("beforerowsinserted", this, start, end);
-            this.liveScroller.un('scroll', this.onLiveScroll, this);
+
             this.rowIndex     = this.rowIndex+recordLen;
             this.lastRowIndex = this.rowIndex;
@@ -826 +849 @@
             this.adjustScrollerPos(this.rowHeight*recordLen, true);
 
-            this.fireEvent("rowsinserted", this, start, end);
-            this.processRows();
+            this.fireEvent("rowsinserted", this, start, end, recordLen);
+            this.processRows(0, undefined, true);
+
             this.fireEvent('cursormove', this, this.rowIndex,
                            Math.min(this.ds.totalLength, this.visibleRows-this.rowClipped),
                            this.ds.totalLength);
-        }
-
-        // rows get added somewhere IN the current view
-        else if ((len < this.visibleRows ) || index > this.rowIndex-this.ds.bufferRange[0]) {
-            firstRow = index;
-            lastRow  = Math.min(end, this.rowIndex+this.visibleRows-1) - this.ds.bufferRange[0];
-            this.insertRows(ds, firstRow, lastRow);
-
-            this.adjustVisibleRows();
-            this.adjustBufferInset();
-
         }
 
@@ -1053 +1066 @@
         var selections = this.grid.selModel.selections;
         var ds         = this.ds;
+        var row        = null;
         for(var i = startRow, len = rows.length; i < len; i++){
-            index   = i+cursor;
-            var row = rows[i];
+            index = i+cursor;
+            row   = rows[i];
             // changed!
             row.rowIndex = index;
@@ -1062 +1076 @@
                 if (this.grid.selModel.bufferedSelections[index] === true) {
                     this.addRowClass(i, "x-grid3-row-selected");
+                } else {
+                    this.removeRowClass(i, "x-grid3-row-selected");
                 }
                 this.fly(row).removeClass("x-grid3-row-over");
@@ -1099 +1115 @@
         // first off, remove the rows at the bottom of the view to match the
         // visibleRows value and to not cause any spill in the DOM
-        if (isUpdate !== true && this.getRows().length == this.visibleRows) {
+        if (isUpdate !== true && (this.getRows().length + (lastRow-firstRow)) >= this.visibleRows) {
             this.removeRows((this.visibleRows-1)-(lastRow-firstRow), this.visibleRows-1);
-        }
-
-        if (isUpdate) {
+        } else if (isUpdate) {
             this.removeRows(viewIndexFirst-this.rowIndex, viewIndexLast-this.rowIndex);
         }
 
-        var html   = this.renderRows(firstRow, lastRow);
+        // compute the range of possible records which could be drawn into the view without
+        // causing any spill
+        var lastRenderRow = (firstRow == lastRow)
+                          ? lastRow
+                          : Math.min(lastRow,  (this.rowIndex-this.ds.bufferRange[0])+(this.visibleRows-1));
+
+        var html = this.renderRows(firstRow, lastRenderRow);
 
         var before = this.getRow(firstRow-(this.rowIndex-this.ds.bufferRange[0]));
@@ -1119 +1139 @@
 
 
-        if (isUpdate === true) {
+        if (!isUpdate === true) {
             var rows   = this.getRows();
             var cursor = this.rowIndex;
@@ -1128 +1148 @@
 
         if (!isUpdate) {
-            this.fireEvent("rowsinserted", this, viewIndexFirst, viewIndexLast);
-            this.processRows();
+            this.fireEvent("rowsinserted", this, viewIndexFirst, viewIndexLast, (viewIndexLast-viewIndexFirst)+1);
+            this.processRows(0, undefined, true);
         }
     },
@@ -1521 +1541 @@
             if (this.getRows()[0]) {
                 this.rowHeight = this.getRows()[0].offsetHeight;
+
+                if (this.rowHeight <= 0) {
+                    this.rowHeight = -1;
+                    return;
+                }
+
             } else {
                 return;
@@ -1565 +1591 @@
             return;
         }
+
         // when re-rendering, doe not take the clipped row into account
         if (this.rowIndex + (visibleRows-this.rowClipped) > totalLength) {

trunk/src/BufferedRowSelectionModel.js

@@ -45 +45 @@
         Ext.ux.grid.BufferedRowSelectionModel.superclass.initEvents.call(this);
 
-        this.grid.store.on('add',            this.onAdd,            this);
+        this.grid.view.on('rowsinserted',    this.onAdd,            this);
         this.grid.store.on('selectionsload', this.onSelectionsLoad, this);
     },
@@ -129 +129 @@
 
     /**
-     * If records where added to the store, this method will work as a callback.
-     * The method gets usually called <b>after</b> the onAdd method of the according
-     * view was called.
+     * If records where added to the store, this method will work as a callback,
+     * called by the views' rowsinserted event.
      * Selections will be shifted down if, and only if, the listeners for the
      * selectiondirty event will return <tt>true</tt>.
      *
      */
-    onAdd : function(store, records, index)
+    onAdd : function(store, index, endIndex, recordLength)
     {
         var ranges       = this.getPendingSelections();
@@ -148 +147 @@
             // in the current buffer range will be shifted up!
             if (rangesLength == 0 && index == Number.MIN_VALUE) {
-                this.shiftSelections(this.grid.getStore().bufferRange[0], records.length);
-            }
-
-            this.fireEvent('selectiondirty', this, index, records.length);
+                this.shiftSelections(this.grid.getStore().bufferRange[0], recordLength);
+            }
+
+            this.fireEvent('selectiondirty', this, index, recordLength);
             return;
         }
 
         if (rangesLength == 0) {
-            this.shiftSelections(this.grid.getStore().bufferRange[0]+index, records.length);
+            this.shiftSelections(index, recordLength);
             return;
         }
@@ -165 +164 @@
         var s         = ranges[0];
         var e         = ranges[rangesLength-1];
-        var viewIndex = this.grid.getStore().bufferRange[0]+index;
+        var viewIndex = index;
         if (viewIndex <= e || viewIndex <= s) {
-            if (this.fireEvent('selectiondirty', this, viewIndex, records.length) !== false) {
-                this.shiftSelections(viewIndex, records.length);
+            if (this.fireEvent('selectiondirty', this, viewIndex, recordLength) !== false) {
+                this.shiftSelections(viewIndex, recordLength);
             }
         }

trunk/src/BufferedStore.js

@@ -124 +124 @@
      * @param {Array}
      */
-    this.bufferRange = [0, this.bufferSize];
+    this.bufferRange = [0, 0];
 
     this.on('clear', function (){
-        this.bufferRange = [0, this.bufferSize];
+        this.bufferRange = [0, 0];
     }, this);
 
@@ -191 +191 @@
         }
         this.totalLength += insertRecords.length;
+
+        // if the store was loaded without data and the bufferRange
+        // has to be filled first
+        if (this.bufferRange[1] < this.bufferSize) {
+            this.bufferRange[1] = Math.min(this.bufferRange[1] + insertRecords.length, this.bufferSize);
+        }
 
         for (var i = 0, len = insertRecords.length; i < len; i++) {