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 "AttachmentSource.h"
#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>
#include <wx/bmpbndl.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 AttachmentSource &attachments, bool remove = true);
 
  Image(Configuration *config, const Image &image);
  Image(const Image &image) = delete;
 
  ~Image();
 
 
  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(const wxString& gnuplotFilename, const wxString& dataFilename,
                     const AttachmentSource &attachments = {});
 
  void CompressedGnuplotSource(wxString gnuplotFilename, wxString dataFilename,
                               const AttachmentSource &attachments = {});
 
  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);
      // An SVG bundle holds the parsed document plus the last bitmap it
      // rendered, at full size. SvgBundle() makes a new one when needed.
      m_svgBundle = wxBitmapBundle();
    }
 
  bool HoldsSvgRendering() const { return m_svgBundle.IsOk(); }
  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;
  }
 
  double GetUserScale() const { return m_userScale; }
  void SetUserScale(double scale) {
    if (scale > 0)
      m_userScale = scale;
  }
  bool GetFitToWindow() const { return m_fitToWindow; }
  void SetFitToWindow(bool fit) { m_fitToWindow = fit; }
 
  void LoadImage(const wxBitmap &bitmap);
 
  wxSize ToImageFile(const 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 IsSvg();}
 
  static const wxString GetBadImageToolTip();
 
  static bool IsSafePath(const wxString &path);
 
  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(const stop_token& stopToken,
                                const wxString& image, const AttachmentSource& attachments,
                                bool remove);
  std::shared_ptr<BackgroundTask> m_loadGnuplotSourceTask;
  void LoadGnuplotSource_Backgroundtask(
    const stop_token& stopToken,
    const wxString& gnuplotFile, const wxString& dataFile, const AttachmentSource& attachments);
  void LoadGnuplotSource(wxInputStream *source);
  void LoadGnuplotData(wxInputStream *data);
  void LoadGnuplotSource_Backgroundtask_internal(
    wxInputStream *source,
    wxInputStream *data);
 
 
  void LoadCompressedGnuplotSource_Backgroundtask(const stop_token& stopToken,
                                                  const wxString& sourcefile,
                                                  const wxString& datafile,
                                                  const AttachmentSource& attachments
    );
  void LoadImage(wxString image, const AttachmentSource &attachments, bool remove = true);
  wxMemoryBuffer ReadCompressedImage(const 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 = nullptr;
  wxCoord m_maxWidth = -1;
  wxCoord m_maxHeight = -1;
  double m_userScale = 1.0;
  bool m_fitToWindow = true;
  wxString m_imageName;
  double m_ppi = 72;
  bool IsSvg() const { return m_extension == wxS("svgz"); }
  const wxBitmapBundle &SvgBundle();
  wxBitmap SvgBitmapAt(wxSize size);
  wxBitmapBundle m_svgBundle;
};
 
#endif // IMAGE_H