ClipboardContents.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 CLIPBOARDCONTENTS_H
#define CLIPBOARDCONTENTS_H
 
#include "precomp.h"
#include <wx/bitmap.h>
#include <wx/dataobj.h>
#include <wx/string.h>
#if wxUSE_ENH_METAFILE
#include <wx/metafile.h>
#endif
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <utility>
 
class Cell;
class GroupCell;
class Configuration;
 
template <class T> class LazyValue
{
public:
  LazyValue() = default;
  explicit LazyValue(std::function<T()> renderer) : m_renderer(std::move(renderer)) {}
 
  bool IsOffered() const { return m_value.has_value() || static_cast<bool>(m_renderer); }
  bool IsRendered() const { return m_value.has_value(); }
 
  const T &Get() const {
    if (!m_value) {
      if (m_renderer)
        m_value = m_renderer();
      else
        m_value = T();
      m_renderer = nullptr;
    }
    return *m_value;
  }
 
private:
  mutable std::function<T()> m_renderer;
  mutable std::optional<T> m_value;
};
 
class ClipboardSnapshot
{
public:
  ClipboardSnapshot(Configuration *configuration, const Cell *cells);
  ~ClipboardSnapshot();
 
  const Cell *GetCells() const { return m_cells.get(); }
  std::unique_ptr<Cell> CopyCells() const;
  Configuration *const *GetConfigurationPointer() const { return &m_configuration; }
  Configuration *GetConfiguration() const { return m_configuration; }
 
private:
  Configuration *m_configuration;
  std::unique_ptr<GroupCell> m_group;
  std::unique_ptr<Cell> m_cells;
};
 
struct ClipboardContents
{
  wxString wxm;
  wxString text;
  LazyValue<std::string> xml;
  LazyValue<std::string> mathML;
  LazyValue<std::string> rtf;
  LazyValue<std::string> svg;
  LazyValue<wxBitmap> bitmap;
#if wxUSE_ENH_METAFILE
  LazyValue<wxEnhMetaFile> emf;
#endif
};
 
class LazyDataObject final : public wxDataObjectSimple
{
public:
  LazyDataObject(const wxDataFormat &format,
                 std::shared_ptr<const LazyValue<std::string>> data);
 
  size_t GetDataSize() const override;
  bool GetDataHere(void *buf) const override;
  bool SetData(size_t len, const void *buf) override;
 
  // Don't hide the base class' per-format overloads, which forward to the
  // ones above.
  using wxDataObjectSimple::GetDataSize;
  using wxDataObjectSimple::GetDataHere;
  using wxDataObjectSimple::SetData;
 
private:
  std::shared_ptr<const LazyValue<std::string>> m_data;
};
 
class LazyBitmapDataObject final : public wxBitmapDataObject
{
public:
  explicit LazyBitmapDataObject(std::shared_ptr<const LazyValue<wxBitmap>> bitmap);
 
  wxBitmap GetBitmap() const override;
  size_t GetDataSize() const override;
  bool GetDataHere(void *buf) const override;
  size_t GetDataSize(const wxDataFormat &format) const override;
  bool GetDataHere(const wxDataFormat &format, void *buf) const override;
 
private:
  bool Render() const;
  std::shared_ptr<const LazyValue<wxBitmap>> m_bitmap;
  mutable bool m_rendered = false;
};
 
class LazyPngDataObject final : public wxDataObjectSimple
{
public:
  explicit LazyPngDataObject(std::shared_ptr<const LazyValue<wxBitmap>> bitmap);
 
  static wxDataFormat GetDataFormat();
 
  size_t GetDataSize() const override;
  bool GetDataHere(void *buf) const override;
  bool SetData(size_t len, const void *buf) override;
 
  // Don't hide the base class' per-format overloads, which forward to the
  // ones above.
  using wxDataObjectSimple::GetDataSize;
  using wxDataObjectSimple::GetDataHere;
  using wxDataObjectSimple::SetData;
 
private:
  const std::string &Png() const;
  std::shared_ptr<const LazyValue<wxBitmap>> m_bitmap;
  mutable std::optional<std::string> m_png;
};
 
#if wxUSE_ENH_METAFILE
class LazyEnhMetaFileDataObject final : public wxEnhMetaFileDataObject
{
public:
  explicit LazyEnhMetaFileDataObject(
    std::shared_ptr<const LazyValue<wxEnhMetaFile>> metafile);
 
  wxEnhMetaFile GetMetafile() const override;
  size_t GetDataSize(const wxDataFormat &format) const override;
  bool GetDataHere(const wxDataFormat &format, void *buf) const override;
 
private:
  bool Render() const;
  std::shared_ptr<const LazyValue<wxEnhMetaFile>> m_metafile;
  mutable bool m_rendered = false;
};
#endif
 
#endif // CLIPBOARDCONTENTS_H