WorksheetSizeMath.h

Go to the documentation of this file.

// -*- mode: c++; c-file-style: "linux"; c-basic-offset: 2; indent-tabs-mode: nil -*-
//
//  Copyright (C) 2026 Gunter Königsmann <wxMaxima@physikbuch.de>
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
//  SPDX-License-Identifier: GPL-2.0+
 
#ifndef WORKSHEETSIZEMATH_H
#define WORKSHEETSIZEMATH_H
 
#include <algorithm>
#include <vector>
 
inline int ComputeWorksheetContentWidth(
    const std::vector<int> &cellWidthsWithMargins, int baseIndent) {
  int width = baseIndent;
  for (int cellWidth : cellWidthsWithMargins)
    width = std::max(width, cellWidth);
  return width;
}
 
struct TrailingGroupGeometry {
  bool sizeIsStale = false;
  int currentY = 0;
  int maxDrop = 0;
};
 
inline int ComputeWorksheetContentHeight(
    const std::vector<TrailingGroupGeometry> &trailing, int groupSkip,
    int baseIndent) {
  int extraHeight = 0;
  for (const TrailingGroupGeometry &cell : trailing) {
    if (cell.sizeIsStale && cell.currentY >= 0)
      // The anchor: its top position is trusted; add its drop and everything
      // accumulated below it.
      return cell.currentY + cell.maxDrop + extraHeight;
    if (cell.sizeIsStale)
      // Stale and not yet positioned (currentY < 0): count its own extent.
      extraHeight += cell.maxDrop + groupSkip;
    else
      // Not stale but still unpositioned mid-layout: reserve a nominal height.
      extraHeight += groupSkip + 20;
  }
  return baseIndent + extraHeight;
}
 
 
struct WorksheetVirtualSize {
  int width = 40;
  int height = 40;
  int scrollUnit = 10;
};
 
inline WorksheetVirtualSize ComputeWorksheetVirtualSize(bool hasTree,
                                                        int maxPointWidth,
                                                        int maxPointHeight,
                                                        int clientHeight,
                                                        int currentScrollPixelY,
                                                        int groupSkip) {
  WorksheetVirtualSize result;
  int scrollUnitBasisHeight = 40;
  if (hasTree)
    scrollUnitBasisHeight = clientHeight;
  result.scrollUnit = std::max(scrollUnitBasisHeight / 30, 10);
  if (hasTree) {
    result.width = maxPointWidth;
    // Allow scrolling one scroll step past the room a horizontal cursor below
    // the last cell needs.
    int height = maxPointHeight + groupSkip + result.scrollUnit;
    // Keep a vertical scrollbar active.
    result.height = std::max(clientHeight + 10, height);
    // Never shrink below what the current scroll position requires.
    result.height =
      std::max(result.height, currentScrollPixelY + clientHeight);
  }
  return result;
}
 
struct ScrollCompensation {
  int scrollUnitsY = 0;
  int topOffset = 0;
};
 
inline ScrollCompensation ComputeScrollCompensation(int scrollUnitsY,
                                                    int scrollUnit,
                                                    int topOffset, int shift) {
  ScrollCompensation result;
  if (scrollUnit < 1)
    scrollUnit = 1;
  // The pixel position the view's top edge must be at, measured in a document
  // whose top offset is 0.
  const int target = scrollUnitsY * scrollUnit + shift - topOffset;
  if (target <= 0) {
    result.scrollUnitsY = 0;
    result.topOffset = std::clamp(-target, 0, scrollUnit - 1);
    return result;
  }
  // Round up to a whole scroll unit and shift the document down by the excess.
  result.scrollUnitsY = (target + scrollUnit - 1) / scrollUnit;
  result.topOffset = result.scrollUnitsY * scrollUnit - target;
  return result;
}
 
class WorksheetView {
public:
  virtual ~WorksheetView() = default;
  virtual void GetViewClientSize(int *width, int *height) const = 0;
  virtual int GetViewScrollUnitY() const = 0;
  virtual void SetViewVirtualSize(int width, int height) = 0;
  virtual void SetViewScrollRate(int rate) = 0;
  virtual void GetViewPosition(int *x, int *y) const = 0;
  virtual void ScrollViewToUnitY(int unitY) = 0;
};
 
struct WorksheetVirtualSizeCache {
  int lastWidth = -1;
  int lastHeight = -1;
};
 
inline void ApplyWorksheetVirtualSize(WorksheetView &view, bool hasTree,
                                      int maxWidth, int maxHeight,
                                      int groupSkip,
                                      WorksheetVirtualSizeCache &cache,
                                      int &scrollUnit) {
  int clientWidth, clientHeight;
  view.GetViewClientSize(&clientWidth, &clientHeight);
 
  int currentScrollPixelY = 0;
  if (hasTree)
    currentScrollPixelY = view.GetViewScrollUnitY() * scrollUnit;
 
  const WorksheetVirtualSize vs = ComputeWorksheetVirtualSize(
    hasTree, maxWidth, maxHeight, clientHeight, currentScrollPixelY,
    groupSkip);
 
  if ((cache.lastWidth != vs.width || cache.lastHeight != vs.height) &&
      vs.height > 0) {
    cache.lastWidth = vs.width;
    cache.lastHeight = vs.height;
    view.SetViewVirtualSize(vs.width, vs.height);
    scrollUnit = vs.scrollUnit;
    view.SetViewScrollRate(vs.scrollUnit);
  }
}
 
#endif