RenderContext.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 RENDERCONTEXT_H
#define RENDERCONTEXT_H
 
#include <wx/brush.h>
#include <wx/dcclient.h>
#include <wx/gdicmn.h>
#include <wx/window.h>
#include <algorithm>
#include <atomic>
#include <chrono>
#include <memory>
#include <vector>
 
class Cell;
 
class RenderContext
{
public:
  RenderContext() = default;
  RenderContext(const RenderContext &o)
    : m_recalcDC(o.m_recalcDC),
      m_canvasSize(o.m_canvasSize),
      m_updateRegion(o.m_updateRegion),
      m_visibleRegion(o.m_visibleRegion),
      m_worksheetPosition(o.m_worksheetPosition),
      m_backgroundBrush(o.m_backgroundBrush),
      m_clipToDrawRegion(o.m_clipToDrawRegion),
      m_printing(o.m_printing)
    {
    }
  RenderContext &operator=(const RenderContext &) = delete;
 
  wxDC *GetRecalcDC() const { return m_recalcDC; }
  void SetRecalcDC(wxDC *dc) { m_recalcDC = dc; }
 
  void AttachWorksheetDC(wxWindow *worksheet)
    {
      m_worksheetDC = std::unique_ptr<wxClientDC>(new wxClientDC(worksheet));
      m_recalcDC = m_worksheetDC.get();
    }
  void DetachWorksheetDC()
    {
      if (m_recalcDC == m_worksheetDC.get())
        m_recalcDC = NULL;
      m_worksheetDC.reset();
    }
 
  wxSize GetCanvasSize() const { return m_canvasSize; }
  void SetCanvasSize(wxSize siz) { m_canvasSize = siz; }
 
  wxRect GetUpdateRegion() const { return m_updateRegion; }
  void SetUpdateRegion(wxRect rect) { m_updateRegion = rect; }
 
  wxRect GetVisibleRegion() const { return m_visibleRegion; }
  void SetVisibleRegion(wxRect visibleRegion) { m_visibleRegion = visibleRegion; }
 
  bool Printing() const { return m_printing; }
  void SetPrinting(bool printing) { m_printing = printing; }
 
  void ClearAndEnableRedrawTracing()
    {
      if (!m_cellRedrawTrace)
        m_cellRedrawTrace.reset(new std::vector<const Cell *>);
      else
        m_cellRedrawTrace->clear();
    }
  void NotifyOfCellRedraw(const Cell *cell)
    {
      // This operation is fast and doesn't allocate after the render context
      // was used for a few screen redraws.
      if (m_cellRedrawTrace && cell)
        m_cellRedrawTrace->push_back(cell);
    }
  template <typename Report> void ReportMultipleRedraws(Report report)
    {
      if (!m_cellRedrawTrace)
        return;
      std::sort(m_cellRedrawTrace->begin(), m_cellRedrawTrace->end());
      size_t counter = 0;
      const Cell *prev = nullptr;
      for (const Cell *cell : *m_cellRedrawTrace) {
        if (prev != cell) {
          if (counter > 1)
            report(counter, prev);
          prev = cell;
          counter = 1;
        } else
          ++counter;
      }
      if (counter > 1)
        report(counter, prev);
    }
 
  bool ClipToDrawRegion() const { return m_clipToDrawRegion; }
  void ClipToDrawRegion(bool clipToDrawRegion)
    { m_clipToDrawRegion = clipToDrawRegion; }
 
  wxPoint GetWorksheetPosition() const { return m_worksheetPosition; }
  void SetWorksheetPosition(wxPoint worksheetPosition)
    { m_worksheetPosition = worksheetPosition; }
 
  wxBrush GetBackgroundBrush() const { return m_backgroundBrush; }
  void SetBackgroundBrush(const wxBrush &brush) { m_backgroundBrush = brush; }
 
  void SetLayoutDeadline(int seconds)
    {
      m_layoutDeadline = std::chrono::steady_clock::now() +
                         std::chrono::seconds(seconds);
      m_layoutCancelled.store(false, std::memory_order_relaxed);
      m_layoutDeadlineActive = true;
    }
  void ClearLayoutCancelled()
    {
      m_layoutDeadlineActive = false;
      m_layoutCancelled.store(false, std::memory_order_relaxed);
    }
  bool IsLayoutCancelled() const
    {
      if (m_layoutCancelled.load(std::memory_order_relaxed))
        return true;
      if (m_layoutDeadlineActive &&
          std::chrono::steady_clock::now() >= m_layoutDeadline) {
        m_layoutCancelled.store(true, std::memory_order_relaxed);
        return true;
      }
      return false;
    }
 
private:
  wxDC *m_recalcDC = nullptr;
  std::unique_ptr<wxClientDC> m_worksheetDC;
  wxSize m_canvasSize;
  wxRect m_updateRegion;
  wxRect m_visibleRegion;
  wxPoint m_worksheetPosition;
  wxBrush m_backgroundBrush;
  bool m_clipToDrawRegion = true;
  bool m_printing = false;
  std::unique_ptr<std::vector<const Cell *>> m_cellRedrawTrace;
  std::chrono::steady_clock::time_point m_layoutDeadline;
  bool m_layoutDeadlineActive = false;
  mutable std::atomic<bool> m_layoutCancelled{false};
};
 
#endif // RENDERCONTEXT_H