scratch_doc.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The 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, you may find one here:
 * http://www.gnu.org/licenses/gpl-3.0.html
 * or you may search the http://www.gnu.org website for the version 3 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */
 
#ifndef KICAD_SCRATCH_DOC_H
#define KICAD_SCRATCH_DOC_H
 
#include <functional>
#include <memory>
#include <utility>
 
#include <kiid.h>
#include <project.h>
#include <settings/settings_manager.h>
#include <wildcards_and_files_ext.h>
 
#include <wx/filename.h>
#include <wx/string.h>
 

class SCRATCH_PROJECT
{
public:
    SCRATCH_PROJECT() = default;
 
    SCRATCH_PROJECT( SETTINGS_MANAGER& aMgr, const wxString& aDocOrProjectPath,
                     bool aRequireProjectFile = false ) :
            m_mgr( &aMgr )
    {
        wxFileName pro( aDocOrProjectPath );
        pro.SetExt( FILEEXT::ProjectFileExtension );
        pro.MakeAbsolute();
 
        const wxString projectPath = pro.GetFullPath();
        const bool     fileMissing = !pro.FileExists();
 
        // Even if a defaults-only slot was loaded earlier by someone else,
        // refuse when the caller demands a real .kicad_pro that doesn't exist.
        // Otherwise the import dialog accepts garbage from a stale slot.
        if( aRequireProjectFile && fileMissing )
            return;
 
        if( PROJECT* existing = aMgr.GetProject( projectPath ) )
        {
            // Someone else already loaded this slot; don't UnloadProject in
            // our dtor or we'd pull the rug out from under them.
            m_project = existing;
            m_owned   = false;
            return;
        }
 
        const bool loadOk = aMgr.LoadProject( projectPath, /*aSetActive=*/false );
        m_project = aMgr.GetProject( projectPath );
 
        if( !m_project )
            return;
 
        m_owned = true;
 
        // Reject a malformed .kicad_pro when the file is present but failed
        // to parse — a defaults-only slot is not a substitute.
        if( !loadOk && !fileMissing )
        {
            release();
            m_project = nullptr;
        }
    }
 
    ~SCRATCH_PROJECT() { release(); }
 
    SCRATCH_PROJECT( const SCRATCH_PROJECT& )            = delete;
    SCRATCH_PROJECT& operator=( const SCRATCH_PROJECT& ) = delete;
 
    SCRATCH_PROJECT( SCRATCH_PROJECT&& aOther ) noexcept { *this = std::move( aOther ); }
 
    SCRATCH_PROJECT& operator=( SCRATCH_PROJECT&& aOther ) noexcept
    {
        if( this != &aOther )
        {
            release();
 
            m_mgr     = std::exchange( aOther.m_mgr, nullptr );
            m_project = std::exchange( aOther.m_project, nullptr );
            m_owned   = std::exchange( aOther.m_owned, false );
        }
 
        return *this;
    }
 
    PROJECT* GetProject() const { return m_project; }

    bool IsValid() const { return m_project != nullptr; }
 
private:
    void release()
    {
        if( m_owned && m_mgr && m_project && m_project != &m_mgr->Prj() )
            m_mgr->UnloadProject( m_project, false );
 
        m_owned = false;
    }
 
    SETTINGS_MANAGER* m_mgr     = nullptr;
    PROJECT*          m_project = nullptr;
    bool              m_owned   = false;
};
 

template<typename DOC>
struct SCRATCH_DOC
{
    using CLEAR_FN = std::function<void( DOC* )>;
 
    SETTINGS_MANAGER*    mgr     = nullptr;
    std::unique_ptr<DOC> doc;
    PROJECT*             project = nullptr;
    CLEAR_FN             clearProject;

    bool                 ownsProject = false;
 
    SCRATCH_DOC() = default;
 
    SCRATCH_DOC( const SCRATCH_DOC& )            = delete;
    SCRATCH_DOC& operator=( const SCRATCH_DOC& ) = delete;
 
    SCRATCH_DOC( SCRATCH_DOC&& aOther ) noexcept { *this = std::move( aOther ); }
 
    SCRATCH_DOC& operator=( SCRATCH_DOC&& aOther ) noexcept
    {
        if( this != &aOther )
        {
            release();
 
            mgr          = std::exchange( aOther.mgr, nullptr );
            doc          = std::move( aOther.doc );
            project      = std::exchange( aOther.project, nullptr );
            ownsProject  = std::exchange( aOther.ownsProject, false );
            clearProject = std::move( aOther.clearProject );
        }
 
        return *this;
    }
 
    ~SCRATCH_DOC() { release(); }
 
private:
    void release()
    {
        if( doc && clearProject )
            clearProject( doc.get() );
 
        doc.reset();
 
        if( mgr && project && ownsProject && project != &mgr->Prj() )
            mgr->UnloadProject( project, false );
 
        mgr         = nullptr;
        project     = nullptr;
        ownsProject = false;
    }
};
 

template<typename DOC, typename Loader, typename ClearFn>
SCRATCH_DOC<DOC> LoadScratchDoc( SETTINGS_MANAGER& aMgr, const wxString& aDocPath,
                                 Loader aLoader, ClearFn aClearFn )
{
    SCRATCH_DOC<DOC> out;
    out.mgr          = &aMgr;
    out.clearProject = aClearFn;
 
    if( aDocPath.IsEmpty() )
        return out;
 
    wxFileName pro( aDocPath );
    pro.SetExt( FILEEXT::ProjectFileExtension );
    pro.MakeAbsolute();
 
    // A document bound to the editor's live project would share and then tear down its
    // settings, so a live path gets a scratch project of its own.
    if( PROJECT* active = aMgr.GetProject( pro.GetFullPath() ); active && active == &aMgr.Prj() )
    {
        pro = wxFileName( wxFileName::GetTempDir(), wxS( "kicad_scratch_" ) + KIID().AsString() );
        pro.SetExt( FILEEXT::ProjectFileExtension );
    }
 
    // LoadProject returns true both when newly loaded AND when already
    // present in the manager (see SETTINGS_MANAGER::LoadProject line 970).
    // We need to know which case we hit so SCRATCH_DOC::release() doesn't
    // double-unload a project shared with another SCRATCH_DOC — query the
    // manager BEFORE LoadProject so we can compare.
    const bool projectAlreadyLoaded = ( aMgr.GetProject( pro.GetFullPath() ) != nullptr );
 
    // LoadProject returns false but still inserts a defaults-only PROJECT
    // when no .kicad_pro exists alongside the document. A present-but-
    // malformed .kicad_pro should be a hard failure though, otherwise the
    // diff/merge runs against garbage settings.
    const bool projectLoadOk = aMgr.LoadProject( pro.GetFullPath(), /*aSetActive=*/false );
    out.project = aMgr.GetProject( pro.GetFullPath() );
 
    if( !out.project )
        return out;
 
    out.ownsProject = !projectAlreadyLoaded;
 
    if( !projectLoadOk && pro.FileExists() )
    {
        if( out.ownsProject && out.project != &aMgr.Prj() )
            aMgr.UnloadProject( out.project, false );
 
        out.project     = nullptr;
        out.ownsProject = false;
        return out;
    }
 
    out.doc = aLoader( out.project );
 
    return out;
}
 
#endif // KICAD_SCRATCH_DOC_H