embedded_files.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors.
 *
 * 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 3 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, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef EMBEDDED_FILES_H
#define EMBEDDED_FILES_H
 
#include <map>
 
#include <wx/string.h>
#include <wx/filename.h>
 
#include <embedded_files_lexer.h>
#include <wildcards_and_files_ext.h>
#include <richio.h>
#include <picosha2.h>
 
class EMBEDDED_FILES
{
public:
 struct EMBEDDED_FILE
 {
 enum class FILE_TYPE
 {
 FONT,
 MODEL,
 WORKSHEET,
 DATASHEET,
 OTHER
 };
 
 EMBEDDED_FILE() :
 type( FILE_TYPE::OTHER ),
 is_valid( false )
 {}
 
 bool Validate()
 {
 std::string new_sha;
 picosha2::hash256_hex_string( decompressedData, new_sha );
 
 is_valid = ( new_sha == data_sha );
 return is_valid;
 }
 
 wxString GetLink() const
 {
 return wxString::Format( "%s://%s", FILEEXT::KiCadUriPrefix, name );
 }
 
 wxString name;
 FILE_TYPE type;
 bool is_valid;
 std::string compressedEncodedData;
 std::vector<char> decompressedData;
 std::string data_sha;
 };
 
 enum class RETURN_CODE : int
 {
 OK, // Success
 FILE_NOT_FOUND, // File not found on disk
 PERMISSIONS_ERROR, // Could not read/write file
 FILE_ALREADY_EXISTS, // File already exists in the collection
 OUT_OF_MEMORY, // Could not allocate memory
 CHECKSUM_ERROR, // Checksum in file does not match data
 };
 
 EMBEDDED_FILES() = default;
 
 ~EMBEDDED_FILES()
 {
 for( auto& file : m_files )
 delete file.second;
 }
 
 EMBEDDED_FILE* AddFile( const wxFileName& aName, bool aOverwrite );
 
 void AddFile( EMBEDDED_FILE* aFile );
 
 void RemoveFile( const wxString& name, bool aErase = true );
 
 void WriteEmbeddedFiles( OUTPUTFORMATTER& aOut, int aNestLevel, bool aWriteData ) const;
 
 wxString GetEmbeddedFileLink( const EMBEDDED_FILE& aFile ) const
 {
 return aFile.GetLink();
 }
 
 bool HasFile( const wxString& name ) const
 {
 wxFileName fileName( name );
 
 return m_files.find( fileName.GetFullName() ) != m_files.end();
 }
 
 bool IsEmpty() const
 {
 return m_files.empty();
 }
 
 const std::vector<wxString>* UpdateFontFiles();
 
 const std::vector<wxString>* GetFontFiles() const;
 
 void ClearEmbeddedFonts();
 
 static RETURN_CODE CompressAndEncode( EMBEDDED_FILE& aFile );
 
 static RETURN_CODE DecompressAndDecode( EMBEDDED_FILE& aFile );
 
 EMBEDDED_FILE* GetEmbeddedFile( const wxString& aName ) const
 {
 auto it = m_files.find( aName );
 
 return it == m_files.end() ? nullptr : it->second;
 }
 
 const std::map<wxString, EMBEDDED_FILE*>& EmbeddedFileMap() const
 {
 return m_files;
 }
 
 wxFileName GetTemporaryFileName( const wxString& aName ) const;
 
 wxFileName GetTemporaryFileName( EMBEDDED_FILE* aFile ) const;
 
 void ClearEmbeddedFiles( bool aDeleteFiles = true )
 {
 for( auto& file : m_files )
 {
 if( aDeleteFiles )
 delete file.second;
 }
 
 m_files.clear();
 }
 
 virtual void EmbedFonts() {};
 
 void SetAreFontsEmbedded( bool aEmbedFonts )
 {
 m_embedFonts = aEmbedFonts;
 }
 
 bool GetAreFontsEmbedded() const
 {
 return m_embedFonts;
 }
 
private:
 std::map<wxString, EMBEDDED_FILE*> m_files;
 std::vector<wxString> m_fontFiles;
 
protected:
 bool m_embedFonts = false; // If set, fonts will be embedded in the element on save
 // Otherwise, font files embedded in the element will be
 // removed on save
};
 
 
 
class EMBEDDED_FILES_PARSER : public EMBEDDED_FILES_LEXER
{
public:
 EMBEDDED_FILES_PARSER( LINE_READER* aReader ) :
 EMBEDDED_FILES_LEXER( aReader )
 {
 }
 
 void ParseEmbedded( EMBEDDED_FILES* aFiles );
 
};
#endif // EMBEDDED_FILES_H