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 (C) 2016-2020 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, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
 */
 
#ifndef KIWAY_H_
#define KIWAY_H_
 
#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 <jobs/job.h>
 
 
#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"
 
#ifndef SWIG
#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
#endif // SWIG
 
class wxConfigBase;
class wxWindow;
class PGM_BASE;
class KIWAY;
class KIWAY_PLAYER;
class wxTopLevelWindow;
class TOOL_ACTION;
 
 
struct KIFACE
{
 // 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 )
 {
 return 0;
 }
};
 
 
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,
 FACE_PYTHON,
 
 KIWAY_FACE_COUNT
 };
 
 ~KIWAY() throw () {}
 
 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 );
 
 virtual void GetActions( std::vector<TOOL_ACTION*>& aActions ) const;
 
 virtual PROJECT& Prj() const;
 
 virtual void SetLanguage( int aLanguage );
 
 virtual void CommonSettingsChanged( bool aEnvVarsChanged, bool aTextVarsChanged );
 
 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;
 
 int ProcessJob( KIWAY::FACE_T aFace, JOB* job );
 
 wxWindow* GetBlockingDialog();
 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 KIFACE* m_kiface[KIWAY_FACE_COUNT];
 static int m_kiface_version[KIWAY_FACE_COUNT];
 
 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];
};
 
 
#ifndef SWIG
// provided by single_top.cpp and kicad.cpp;
extern KIWAY Kiway;
// whereas python launchers: single_top.py and project manager instantiate as a python object
#endif
 
 
typedef KIFACE* KIFACE_GETTER_FUNC( int* aKIFACEversion, int aKIWAYversion, PGM_BASE* aProgram );
 
 
#ifndef SWIG
 
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 // SWIG
 
#endif // KIWAY_H_