Preload margin with length and sides instead of number of rows

Author: RockinRoel

src/Wt/WTableView.C

@@ -58,7 +58,6 @@ WTableView::WTableView()
     dropEvent_(impl_, "dropEvent"),
     scrolled_(impl_, "scrolled"),
     itemTouchSelectEvent_(impl_, "itemTouchSelectEvent"),
-    preloadMarginRows_(-1),
     firstColumn_(-1),
     lastColumn_(-1),
     viewportLeft_(0),
@@ -69,6 +68,8 @@ WTableView::WTableView()
     scrollToHint_(ScrollHint::EnsureVisible),
     columnResizeConnected_(false)
 {
+  preloadMargin_[0] = preloadMargin_[1] = preloadMargin_[2] = preloadMargin_[3] = WLength();
+
   setSelectable(false);
 
   setStyleClass("Wt-itemview Wt-tableview");
@@ -686,14 +687,15 @@ void WTableView::renderTable(const int fr, const int lr,
   assert(lastRow() == lr && firstRow() == fr);
   assert(lastColumn() == lc && firstColumn() == fc);
 
-  const int marginHeight = preloadMarginRows_ == -1 ?
-        viewportHeight_ / 2 :
-        static_cast<int>(preloadMarginRows_ * rowHeight().toPixels()) / 2;
+  const int marginTop = static_cast<int>(std::round((preloadMargin(Side::Top).isAuto() ? viewportHeight_ : preloadMargin(Side::Top).toPixels()) / 2));
+  const int marginBottom = static_cast<int>(std::round((preloadMargin(Side::Bottom).isAuto() ? viewportHeight_ : preloadMargin(Side::Bottom).toPixels()) / 2));
+  const int marginLeft = static_cast<int>(std::round((preloadMargin(Side::Left).isAuto() ? viewportWidth_ : preloadMargin(Side::Left).toPixels()) / 2));
+  const int marginRight = static_cast<int>(std::round((preloadMargin(Side::Right).isAuto() ? viewportWidth_ : preloadMargin(Side::Right).toPixels()) / 2));
 
-  int scrollX1 = std::max(0, viewportLeft_ - viewportWidth_ / 2);
-  int scrollX2 = viewportLeft_ + viewportWidth_ / 2;
-  int scrollY1 = std::max(0, viewportTop_ - marginHeight);
-  int scrollY2 = viewportTop_ + marginHeight;
+  int scrollX1 = std::max(0, viewportLeft_ - marginLeft);
+  int scrollX2 = viewportLeft_ + marginRight;
+  int scrollY1 = std::max(0, viewportTop_ - marginTop);
+  int scrollY2 = viewportTop_ + marginBottom;
 
   WStringStream s;
 
@@ -1637,7 +1639,6 @@ void WTableView::computeRenderedArea()
 {
   if (ajaxMode()) {
     const int borderRows = 5;
-    const int borderColumnPixels = 200;
 
     int modelHeight = 0;
     if (model())
@@ -1651,19 +1652,22 @@ void WTableView::computeRenderedArea()
       const int height = std::min(viewportHeight_,
 			    static_cast<int>(canvas_->height().toPixels()));
 
-      const int renderedRows = static_cast<int>(height / rowHeight().toPixels()
-					  + 0.5);
+      const int renderedRows = static_cast<int>(std::ceil(height / rowHeight().toPixels()));
 
-      renderedFirstRow_ = static_cast<int>(top / rowHeight().toPixels());
+      const int renderedRowsAbove = preloadMargin(Side::Top).isAuto() ? renderedRows + borderRows :
+                                                               static_cast<int>(std::round(preloadMargin(Side::Top).toPixels() / rowHeight().toPixels()));
 
-      const int marginRows = preloadMarginRows_ == -1 ? renderedRows + borderRows : preloadMarginRows_;
+      const int renderedRowsBelow = preloadMargin(Side::Bottom).isAuto() ? renderedRows + borderRows :
+                                                                  static_cast<int>(std::round(preloadMargin(Side::Bottom).toPixels() / rowHeight().toPixels()));
+
+      renderedFirstRow_ = static_cast<int>(top / rowHeight().toPixels());
 
       renderedLastRow_
-        = static_cast<int>(std::min(static_cast<long long>(renderedFirstRow_) + renderedRows + marginRows,
+        = static_cast<int>(std::min(static_cast<long long>(renderedFirstRow_) + renderedRows + renderedRowsBelow,
                    static_cast<long long>(modelHeight - 1)));
       renderedFirstRow_
-        = static_cast<int>(std::max(static_cast<long long>(renderedFirstRow_) - marginRows,
-                                    0LL));
+        = static_cast<int>(std::max(static_cast<long long>(renderedFirstRow_) - renderedRowsAbove,
+                                    static_cast<long long>(0)));
     } else {
       renderedFirstRow_ = 0;
       renderedLastRow_ = modelHeight - 1;
@@ -1672,17 +1676,22 @@ void WTableView::computeRenderedArea()
     if (renderedFirstRow_ % 2 == 1)
       --renderedFirstRow_;
 
+    const int borderColumnPixels = 200;
+    const int marginLeft = static_cast<int>(std::round(preloadMargin(Side::Left).isAuto() ? viewportWidth_ + borderColumnPixels : preloadMargin(Side::Left).toPixels()));
+    const int marginRight = static_cast<int>(std::round(preloadMargin(Side::Right).isAuto() ? viewportWidth_ + borderColumnPixels : preloadMargin(Side::Right).toPixels()));
+
     /* column range */
     int left
-      = std::max(0, viewportLeft_ - viewportWidth_ - borderColumnPixels);
+      = static_cast<int>(std::max(static_cast<long long>(0),
+                                  static_cast<long long>(viewportLeft_) - marginLeft));
     int right
-      = std::min(std::max(static_cast<int>(canvas_->width().toPixels()),
-                          viewportWidth_), // When a column was made wider, and the
-                                           // canvas is narrower than the viewport,
-                                           // the size of the canvas will not have
-                                           // been updated yet, so we use the viewport
-                                           // width instead.
-		 viewportLeft_ + 2 * viewportWidth_ + borderColumnPixels);
+      = static_cast<int>(std::min(static_cast<long long>(std::max(static_cast<int>(canvas_->width().toPixels()),
+                                        viewportWidth_)), // When a column was made wider, and the
+                                                         // canvas is narrower than the viewport,
+                                                         // the size of the canvas will not have
+                                                         // been updated yet, so we use the viewport
+                                                         // width instead.
+                         static_cast<long long>(viewportLeft_) + viewportWidth_ + marginRight));
 
     int total = 0;
     renderedFirstColumn_ = rowHeaderCount();
@@ -2118,15 +2127,42 @@ void WTableView::setOverflow(Overflow overflow,
     contentsContainer_->setOverflow(overflow, orientation);
 }
 
-void WTableView::setPreloadMarginRows(int rows)
+void WTableView::setPreloadMargin(const WLength &margin, WFlags<Side> side)
 {
-  preloadMarginRows_ = rows;
+  if (side.test(Side::Top)) {
+    preloadMargin_[0] = margin;
+  }
+  if (side.test(Side::Right)) {
+    preloadMargin_[1] = margin;
+  }
+  if (side.test(Side::Bottom)) {
+    preloadMargin_[2] = margin;
+  }
+  if (side.test(Side::Left)) {
+    preloadMargin_[3] = margin;
+  }
 
   computeRenderedArea();
 
   scheduleRerender(RenderState::NeedAdjustViewPort);
 }
 
+WLength WTableView::preloadMargin(Side side) const
+{
+  switch (side) {
+  case Side::Top:
+    return preloadMargin_[0];
+  case Side::Right:
+    return preloadMargin_[1];
+  case Side::Bottom:
+    return preloadMargin_[2];
+  case Side::Left:
+    return preloadMargin_[3];
+  default:
+    return WLength();
+  }
+}
+
 void WTableView::setRowHeaderCount(int count)
 {
   WAbstractItemView::setRowHeaderCount(count);

src/Wt/WTableView.h

@@ -123,24 +123,30 @@ class WT_API WTableView : public WAbstractItemView
 		   WFlags<Orientation> orientation 
 		   = (Orientation::Horizontal | Orientation::Vertical));
 
-  /*! \brief Sets the amount of rows to preload.
+  /*! \brief Sets preloading margin
    *
-   * Configures the amount of rows before and after the currently visible
-   * range that should be loaded. If N rows are shown, and C is the margin,
-   * then N + 2C rows are loaded: N visible, C rows before, and C rows after.
+   * By default the table view loads in an area equal to 3 times its height
+   * and 3 times its width. This makes it so that the user can scroll a full
+   * page in each direction without the delay caused when the table view
+   * dynamically needs to load more data.
    *
-   * Set to 0 if you don't want to load more rows than are currently visible.
+   * setPreloadMargin() allows to customize this margin.
    *
-   * Set to -1 if you want to keep default behaviour. This means that if N rows
-   * are visible, then 3N rows are loaded: N visible, N rows before, and N rows after.
+   * e.g. if the table view is H pixels high, and C is the preload margin in pixels
+   * set on the top and bottom, then enough rows are loaded to fill the area
+   * that is H + 2C pixels high. H pixels visible, C pixels above, and C pixels below.
+   *
+   * Set to 0 pixels if you don't want to load more rows or columns than are currently visible.
+   *
+   * Set to a default-constructed WLength (auto) if you want to keep default behaviour.
    */
-  void setPreloadMarginRows(int rows);
+  void setPreloadMargin(const WLength &margin, WFlags<Side> side = AllSides);
 
-  /*! \brief Get the preload margin.
+  /*! \brief Retrieves the preloading margin
    *
-   * \sa setPreloadMarginRows()
+   * \sa setPreloadMargin
    */
-  int preloadMarginRows() const { return preloadMarginRows_; }
+  WLength preloadMargin(Side side) const;
 
   virtual void setHidden(bool hidden,
 			 const WAnimation& animation = WAnimation()) override;
@@ -195,7 +201,7 @@ class WT_API WTableView : public WAbstractItemView
   Signals::connection touchMoveConnection_;
   Signals::connection touchEndConnection_;
 
-  int preloadMarginRows_;
+  WLength preloadMargin_[4];
 
   /* Ajax only: First and last columns rendered (this somewhat
    * redundant with the state contained in the widgets, but because