kiway.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2014 SoftPLC Corporation, Dick Hollenbeck <[email protected]>
 * 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 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, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef KIWAY_H_
#define KIWAY_H_

 
 
#include <array>
#include <atomic>
#include <wx/defs.h>
#include <wx/event.h>
#include <import_export.h>
#include <search_stack.h>
#include <project.h>
#include <frame_type.h>
#include <mail_type.h>
#include <ki_exception.h>
#include <lib_id.h>
 
class KICAD_API_SERVER;
 
 
#define KIFACE_VERSION      1
#define KIFACE_GETTER       KIFACE_1
 
// The KIFACE acquisition function is declared extern "C" so its name should not
// be mangled.
#define KIFACE_INSTANCE_NAME_AND_VERSION   "KIFACE_1"
 
#if defined(__linux__) || defined(__FreeBSD__)
 #define LIB_ENV_VAR    wxT( "LD_LIBRARY_PATH" )
#elif defined(__WXMAC__)
 #define LIB_ENV_VAR    wxT( "DYLD_LIBRARY_PATH" )
#elif defined(_WIN32)
 #define LIB_ENV_VAR    wxT( "PATH" )
#else
 #error Platform support missing
#endif
 
class wxConfigBase;
class wxWindow;
class PGM_BASE;
class KIWAY;
class KIWAY_PLAYER;
class wxTopLevelWindow;
class TOOL_ACTION;
class JOB;
class REPORTER;
class PROGRESS_REPORTER;
class STARTWIZARD_PROVIDER;
class LOCAL_HISTORY;
 

struct KIFACE
{
    struct DOCUMENT_SPEC
    {
        enum class KIND
        {
            FILE_KIND,   
            LIBID_KIND,  
            CREATE_KIND, 
        };
 
        KIND     kind = KIND::FILE_KIND;
        wxString path;               
        LIB_ID   libId;              
    };
 
    // The order of functions establishes the vtable sequence, do not change the
    // order of functions in this listing unless you recompile all clients of
    // this interface.
 
    virtual ~KIFACE() throw() {}
 
#define KFCTL_STANDALONE ( 1 << 0 )        
#define KFCTL_CPP_PROJECT_SUITE ( 1 << 1 ) 
#define KFCTL_CLI ( 1 << 2 )               
 

    virtual bool OnKifaceStart( PGM_BASE* aProgram, int aCtlBits, KIWAY* aKiway ) = 0;

    virtual void OnKifaceEnd() = 0;

    virtual void Reset() = 0;

    virtual wxWindow* CreateKiWindow( wxWindow* aParent, int aClassId,
                                      KIWAY* aKIWAY, int aCtlBits = 0 ) = 0;

    virtual void SaveFileAs( const wxString& srcProjectBasePath,
                             const wxString& srcProjectName,
                             const wxString& newProjectBasePath,
                             const wxString& newProjectName,
                             const wxString& srcFilePath,
                             wxString& aErrors )
    {
        // If a KIFACE owns files then it needs to implement this....
    }

    virtual void* IfaceOrAddress( int aDataId ) = 0;

    virtual void GetActions( std::vector<TOOL_ACTION*>& aActions ) const = 0;
 
    virtual int HandleJob( JOB* aJob, REPORTER* aReporter, PROGRESS_REPORTER* aProgressReporter )
    {
        return 0;
    }
 
    virtual bool HandleJobConfig( JOB* aJob, wxWindow* aParent )
    {
        return 0;
    }
 
    virtual bool HandleApiOpenDocument( const DOCUMENT_SPEC& aSpec,
                                        KICAD_API_SERVER* aServer,
                                        wxString* aError )
    {
        if( aError )
            *aError = wxS( "OpenDocument is not implemented for this face" );
 
        return false;
    }

    virtual bool HandleApiCloseDocument( const DOCUMENT_SPEC& aSpec, KICAD_API_SERVER* aServer, wxString* aError )
    {
        if( aError )
            *aError = wxS( "CloseDocument is not implemented for this face" );
 
        return false;
    }
 
    virtual void PreloadLibraries( KIWAY* aKiway ) {}
 
    virtual void CancelPreload( bool aBlock = true ) {}
 
    virtual void ProjectChanged() {}

    virtual void RegisterLibraryHandlers( KICAD_API_SERVER* aServer ) {}

    virtual bool LoadAllLibraries() { return false; }
};
 

class KICOMMON_API KIWAY : public wxEvtHandler
{
    friend struct PGM_SINGLE_TOP;        // can use set_kiface()
 
public:
    enum FACE_T
    {
        FACE_SCH,               
        FACE_PCB,               
        FACE_CVPCB,
        FACE_GERBVIEW,
        FACE_PL_EDITOR,
        FACE_PCB_CALCULATOR,
        FACE_BMP2CMP,
 
        KIWAY_FACE_COUNT
    };
 
    ~KIWAY();

    static FACE_T KifaceType( FRAME_T aFrameType );
 
    // If you change the vtable, recompile all of KiCad.

    virtual KIFACE* KiFACE( FACE_T aFaceId, bool doLoad = true );

    virtual KIWAY_PLAYER* Player( FRAME_T aFrameType, bool doCreate = true,
                                  wxTopLevelWindow* aParent = nullptr );

    virtual bool PlayerClose( FRAME_T aFrameType, bool doForce );

    virtual bool PlayersClose( bool doForce );

    void PlayerDidClose( FRAME_T aFrameType );

    virtual void ExpressMail( FRAME_T aDestination, MAIL_T aCommand, std::string& aPayload,
                              wxWindow* aSource = nullptr, bool aFromOtherThread = false );

    virtual void GetActions( std::vector<TOOL_ACTION*>& aActions ) const;

    virtual PROJECT& Prj() const;

    LOCAL_HISTORY& LocalHistory() { return *m_local_history; }

    virtual void SetLanguage( int aLanguage );

    virtual void CommonSettingsChanged( int aFlags = 0 );

    void ClearFileHistory();

    virtual void ProjectChanged();
 
    KIWAY( int aCtlBits, wxFrame* aTop = nullptr );

    void SetCtlBits( int aCtlBits ) { m_ctl = aCtlBits; }

    void SetTop( wxFrame* aTop );
    wxFrame* GetTop() { return m_top; }
 
    void OnKiCadExit();
 
    void OnKiwayEnd();
 
    bool ProcessEvent( wxEvent& aEvent ) override;
 
    void QueueEvent( wxEvent* aEvent ) override;
 
    int  ProcessJob( KIWAY::FACE_T aFace, JOB* aJob, REPORTER* aReporter = nullptr,
                     PROGRESS_REPORTER* aProgressReporter = nullptr );
    bool ProcessApiCloseDocument( KIWAY::FACE_T aFace, const KIFACE::DOCUMENT_SPEC& aSpec,
                                  KICAD_API_SERVER* aServer,
                                  wxString* aError = nullptr );
    bool ProcessJobConfigDialog( KIWAY::FACE_T aFace, JOB* aJob, wxWindow* aWindow );
 
    bool ProcessApiOpenDocument( KIWAY::FACE_T aFace, const KIFACE::DOCUMENT_SPEC& aSpec,
                                 KICAD_API_SERVER* aServer,
                                 wxString* aError = nullptr );

    wxWindow* GetBlockingDialog();
    bool HasBlockingDialog() const { return m_blockingDialog != wxID_NONE; }
    void SetBlockingDialog( wxWindow* aWin );
 
private:
    const wxString dso_search_path( FACE_T aFaceId );
 
    bool set_kiface( FACE_T aFaceType, KIFACE* aKiface )
    {
        if( (unsigned) aFaceType < (unsigned) KIWAY_FACE_COUNT )
        {
            m_kiface[aFaceType] = aKiface;
            return true;
        }
 
        return false;
    }

    KIWAY_PLAYER* GetPlayerFrame( FRAME_T aFrameType );
 
    static std::array<KIFACE*,KIWAY_FACE_COUNT>  m_kiface;
    static std::array<int,KIWAY_FACE_COUNT>      m_kiface_version;
 
    int             m_ctl;
 
    wxFrame*        m_top;      // Usually m_top is the Project manager
 
    wxWindowID      m_blockingDialog;
 
    // An array to store the window ID of PLAYER frames which were run.
    // A non empty name means only a PLAYER was run at least one time.
    // Empty entries are represented by wxID_NONE.
    // They can be closed, and the stored window ID may be invalid.
    // Call: wxWindow::FindWindowById( m_playerFrameId[aFrameType] )
    // to know if still exists (or GetPlayerFrame( FRAME_T aFrameType )
    std::atomic<wxWindowID> m_playerFrameId[KIWAY_PLAYER_COUNT];
 
    LOCAL_HISTORY*  m_local_history;
};
 
 
extern KIWAY Kiway;
 

typedef KIFACE* KIFACE_GETTER_FUNC( int* aKIFACEversion, int aKIWAYversion, PGM_BASE* aProgram );
 

extern "C" {
#if defined(BUILD_KIWAY_DLL)
    KIFACE_API KIFACE* KIFACE_GETTER(  int* aKIFACEversion, int aKIWAYversion, PGM_BASE* aProgram );
#else
    KIFACE* KIFACE_GETTER(  int* aKIFACEversion, int aKIWAYversion, PGM_BASE* aProgram );
#endif
}
 
#endif  // KIWAY_H_