Image.h

Go to the documentation of this file.

// -*- mode: c++; c-file-style: "linux"; c-basic-offset: 2; indent-tabs-mode: nil -*-
//
//  Copyright (C) 2004-2015 Andrej Vodopivec <andrej.vodopivec@gmail.com>
//            (C) 2014-2015 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 IMAGE_H
#define IMAGE_H
 
#include <memory>
#include <thread>
#include "BackgroundQueue.h"
#include "precomp.h"
#include "Compat.h"
#include "Configuration.h"
#include <wx/image.h>
#include <wx/buffer.h>
#include <wx/zipstrm.h>
#include <wx/wfstream.h>
#define NANOSVG_ALL_COLOR_KEYWORDS
#include "nanosvg_private.h"
#include "nanosvgrast_private.h"
 
 
class Image final
{
public:
  explicit Image(Configuration *config);
 
  Image(Configuration *config, const wxMemoryBuffer &image, const wxString &type);
 
  Image(Configuration *config, const wxBitmap &bitmap);
 
  Image(Configuration *config, const wxString &image,
        const wxString &wxmxFile, bool remove = true);
 
  Image(Configuration *config, const Image &image);
  Image(const Image &image) = delete;
 
  ~Image();
 
  static wxBitmap RGBA2wxBitmap(const unsigned char imgdata[],
                                const int &width, const int &height);
 
  void SetConfiguration(Configuration *config){
    if(m_loadImageTask)
      m_loadImageTask->Wait();
    m_configuration = config; }
  int GetPPI() const {
    if(m_loadImageTask)
      m_loadImageTask->Wait();
    return m_ppi;}
  void SetPPI(int ppi) {
    if(m_loadImageTask)
      m_loadImageTask->Wait();
    m_ppi = ppi;}
 
  void InvalidBitmap(const wxString &message = wxEmptyString);
  void GenerateInvalidBitmap();
 
  wxString m_invalidBitmapMessage;
  bool m_isInvalid = false;
 
  enum class LoadFailureKind {
    None,
    DataUnavailable,
    MissingCodec,
    DecodeFailed,
  };
  LoadFailureKind GetLoadFailureKind() const {
    if (m_loadImageTask)
      m_loadImageTask->Wait();
    return m_loadFailureKind;
  }
 
  void GnuplotSource(wxString gnuplotFilename, wxString dataFilename,
                     const wxString &wxmxFile = wxEmptyString);
 
  void CompressedGnuplotSource(wxString gnuplotFilename, wxString dataFilename,
                               const wxString &wxmxFile = wxEmptyString);
 
  wxString GnuplotSource();
  wxString GnuplotData();
 
  const wxMemoryBuffer GetGnuplotSource();
  const wxMemoryBuffer GetCompressedGnuplotSource();
  const wxMemoryBuffer GetGnuplotData();
  const wxMemoryBuffer GetCompressedGnuplotData();
 
  void ClearCache()
    {
      if(m_loadImageTask)
        m_loadImageTask->Wait();
      // Querying the size of an invalid bitmap trips a wxWidgets assertion (and,
      // under a GUI assert handler, hangs). A not-yet-rendered cache is already
      // "clear", so only shrink a bitmap that actually exists.
      if (m_scaledBitmap.IsOk() &&
          ((m_scaledBitmap.GetWidth() > 1) || (m_scaledBitmap.GetHeight() > 1)))
        m_scaledBitmap.Create(1, 1);
    }
 
  wxString GetExtension() const;
  double GetMaxWidth() const {
    if(m_loadImageTask)
      m_loadImageTask->Wait();
    return m_maxWidth;}
  double GetHeightList() const {
    if(m_loadImageTask)
      m_loadImageTask->Wait();
    return m_maxHeight;}
  void   SetMaxWidth(double width){
    if(m_loadImageTask)
      m_loadImageTask->Wait();
    m_maxWidth = width;
  }
  void   SetMaxHeight(double height){
    if(m_loadImageTask)
      m_loadImageTask->Wait();
    m_maxHeight = height;
  }
 
  void LoadImage(const wxBitmap &bitmap);
 
  wxSize ToImageFile(wxString filename);
 
  wxBitmap GetBitmap(double scale = 1.0);
 
  wxBitmap GetUnscaledBitmap();
 
  void Recalculate(double scale = 1.0);
 
  long m_width = 1;
  long m_height = 1;
 
  const wxMemoryBuffer GetCompressedImage() const;
 
  std::size_t GetOriginalWidth() const;
 
  std::size_t GetOriginalHeight() const;
 
 
 
  wxMemoryBuffer m_compressedImage;
 
  bool CanExportSVG() const {
    if(m_loadImageTask)
      m_loadImageTask->Wait();
    return m_svgRast != nullptr;}
 
  static const wxString GetBadImageToolTip();
 
  static bool IsSafePath(const wxString &path);
 
  class WxmxStream: public wxZipInputStream
  {
  public:
    WxmxStream(wxInputStream &wxmxFile, const wxString &fileInWxmx);
  };
 
  bool HasGnuplotSource() const {return m_gnuplotSource_Compressed.GetDataLen() > 20;}
private:
  bool m_fromWxFS = false;
  wxMemoryBuffer m_gnuplotSource_Compressed;
  wxMemoryBuffer m_gnuplotData_Compressed;
  std::size_t m_originalWidth = 640;
  std::size_t m_originalHeight = 480;
  wxBitmap m_scaledBitmap;
  wxString m_extension;
  wxString m_gnuplotSource;
  wxString m_gnuplotData;
  mutable std::shared_ptr<BackgroundTask> m_loadImageTask;
  void LoadImage_Backgroundtask(stop_token stopToken,
                                wxString image, wxString wxmxFile,
                                bool remove);
  std::shared_ptr<BackgroundTask> m_loadGnuplotSourceTask;
  void LoadGnuplotSource_Backgroundtask(
    stop_token stopToken,
    wxString gnuplotFile, wxString dataFile, wxString wxmxFile);
  void LoadGnuplotSource(wxInputStream *source);
  void LoadGnuplotData(wxInputStream *data);
  void LoadGnuplotSource_Backgroundtask_internal(
    wxInputStream *source,
    wxInputStream *data);
 
 
  void LoadCompressedGnuplotSource_Backgroundtask(stop_token stopToken,
                                                  wxString sourcefile,
                                                  wxString datafile,
                                                  wxString wxmxFile
    );
  void LoadImage(wxString image, const wxString &wxmxFile, bool remove = true);
  wxMemoryBuffer ReadCompressedImage(stop_token stopToken, wxInputStream *data);
  void RecordDataUnavailable(const wxString &message);
  void RecordDecodeFailure(const wxString &message, bool missingCodec);
  LoadFailureKind m_loadFailureKind = LoadFailureKind::None;
  Configuration *m_configuration = NULL;
  wxCoord m_maxWidth = -1;
  wxCoord m_maxHeight = -1;
  wxString m_imageName;
  double m_ppi = 72;
  struct free_deleter { void operator()(void *p) const { std::free(p); } };
  wxm_NSVGimage* m_svgImage = {};
  std::unique_ptr<struct wxm_NSVGrasterizer, free_deleter> m_svgRast{nullptr};
};
 
#endif // IMAGE_H