kicad/include/project.h

#ifndef PROJECT_H_
#define PROJECT_H_
/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2014 KiCad Developers, see CHANGELOG.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
 */

#include <vector>
#include <wx/string.h>
#include <wx/filename.h>
#include <search_stack.h>

/// A variable name whose value holds the current project directory.
/// Currently an environment variable, eventually a project variable.
#define PROJECT_VAR_NAME            wxT( "KIPRJMOD" )


class wxConfigBase;
class PARAM_CFG_ARRAY;


#define VTBL_ENTRY      virtual

/**
 * Class PROJECT
 * holds project specific data.  Because it is in the neutral program top, which
 * is not linked to by subsidiarly DSOs, any functions in this interface must
 * be VTBL_ENTRYs.
 */
class PROJECT
{
public:

    /// Derive PROJECT elements from this, it has a virtual destructor, and
    /// Elem*() functions can work with it.  Implementation is opaque in
    /// class PROJECT.  If find you have to include derived class headers in this
    /// file, you are doing something wrong.  Keep knowledge of derived classes
    /// opaque to class PROJECT please.
    class _ELEM
    {
    public:
        virtual ~_ELEM() {}
    };

    PROJECT();
    ~PROJECT();

    // VTBL_ENTRY bool MaybeLoadProjectSettings( const std::vector<wxString>& aFileSet );

    /**
     * Function SetProjectFullName
     * sets the:
     * 1) full directory, 2) basename, and 3) extension of the project.  This is
     * the name of the *.pro file with full absolute path and it also defines
     * the name of the project.  The project name and the *.pro file names are
     * exactly the same, providing the *.pro filename is absolute.
     */
    VTBL_ENTRY void SetProjectFullName( const wxString& aFullPathAndName );

    /**
     * Function GetProjectFullName
     * returns the full path and name of the project.  This is the same as the
     * name of the *.pro file and will always be an absolute path.
     */
    VTBL_ENTRY const wxString GetProjectFullName() const;

    /**
     * Function FootprintLibTblName
     * returns the path and filename of this project's fp-lib-table,
     * i.e. the project specific one, not the global one.
     */
    VTBL_ENTRY const wxString FootprintLibTblName() const;

    /**
     * Function ConfigSave
     * saves the current "project" parameters into the wxConfigBase* derivative.
     * Then the wxConfigBase derivative is written to the *.pro file for the project.
     *
     * @param aSearchS a SEARCH_STACK
     * @param aFileName is where to save the *.pro file.
     * @param aGroupName
     * @param aParams is a ptr vector of PARAM_CFG_BASE derivatives.
     *  Saved parameters are the subset in this array having the .m_Setup member
     *  set to false.
     */
    VTBL_ENTRY void ConfigSave( const SEARCH_STACK& aSearchS, const wxString& aFileName,
            const wxString&  aGroupName, const PARAM_CFG_ARRAY& aParams );

    /**
     * Function ConfigLoad
     * reads a subset of parameters from the "project" file.  Parameters are the
     * subset of variables given in @a aParams array which have the .m_Setup member
     * set to false.  The file which is read in and then extracted from is the
     * '*.pro' file for the project.
     * <p>
     * set:
     *  m_pro_date_and_time
     *  m_pro_name
     *
     * @param aSearchS a SEARCH_STACK where a kicad.pro template file may be found.
     * @param aLocalConfigFileName
     * @param aGroupName
     * @param aParams is ptr vector of PARAM_CFG_BASE derivatives.
     * @param doLoadOnlyIfNew if true, then this file is read only if it differs from
     * the current config on date (different dates), else the *.pro file is read and
     * extracted from unconditionally.
     *
     * @return bool - true if loaded OK.
     */
    VTBL_ENTRY bool ConfigLoad( const SEARCH_STACK& aSearchS, const wxString& aLocalConfigFileName,
            const wxString& aGroupName, const PARAM_CFG_ARRAY& aParams, bool doLoadOnlyIfNew );

    /// Accessor for Eeschema search stack.
    VTBL_ENTRY SEARCH_STACK&  SchSearchS()      { return m_sch_search; }

    VTBL_ENTRY  wxString GetModuleLibraryNickname()     { return m_module_library_nickname; }
    VTBL_ENTRY  void SetModuleLibraryNickname( const wxString& aNickName ) {  m_module_library_nickname = aNickName; }

    /// Retain a number of paths for user convienience, enumerated here:
    enum RETPATH_T
    {
        DOC,
        SCH_LIB,
        PCB_LIB,
        VIEWER_3D,

        RPATH_COUNT
    };

    /// Give acess to a RETAINED_PATH using enum RETPATH_T
    VTBL_ENTRY  RETAINED_PATH& RPath( RETPATH_T aPath );

    /**
     * Enum ELEM_T
     * is the set of _ELEMs that a PROJECT can hold.
     */
    enum ELEM_T
    {
        FPTBL,

        ELEM_COUNT
    };

    /**
     * A PROJECT can hold stuff it knows nothing about, in the form of
     * _ELEM derivatives.  This function gives access to a PROJECT::_ELEM using
     * enum ELEM_T as an index.
     * <p>
     * Acts as setter iff aElem is not NULL, else getter.
     * <p>
     * Typically wrapped somewhere else in a more meaningful function wrapper.
     * This is a cross module API, therefore the _ELEM destructor is virtual and
     * can point to a destructor function in another link image.  Be careful that
     * that program module is resident at time of destruction.
     * <p>
     * Summary: 1) cross module API, 2) PROJECT knows nothing about _ELEM objects,
     * except how to delete them and set and get pointers to them.
     */
    VTBL_ENTRY  _ELEM*  Elem( ELEM_T aIndex, _ELEM* aElem = NULL );

private:

    /**
     * Function configCreate
     * creates or recreates the KiCad project file and wxConfigBase:
     *
     *      <project_name>.pro
     *
     * @param aFilename is a local configuration file path and basename.
     *
     * Initializes ?
     * G_Prj_Config
     * G_Prj_Config_LocalFilename
     * G_Prj_Default_Config_FullFilename
     * :
     */
    wxConfigBase* configCreate( const SEARCH_STACK& aSearchS,
            const wxString& aFilename, const wxString& aGroupName,
            bool aForceUseLocalConfig );

    SEARCH_STACK    m_sch_search;           ///< Eeschema's search paths
    SEARCH_STACK    m_pcb_search;           ///< Pcbnew's obsolete footprint search paths, see comment above.

    wxFileName      m_project_name;         ///< <fullpath>/<basename>.pro
    wxString        m_pro_date_and_time;

    wxString        m_module_library_nickname;  ///< @todo move this into m_rpaths[]

    /// @see this::RPath() and enum RETPATH_T.
    RETAINED_PATH   m_rpaths[RPATH_COUNT];

    /// @see this::Elem() and enum ELEM_T.
    _ELEM*          m_elems[ELEM_COUNT];
};


//-----<possible futures>---------------------------------------------------------

#if 0
    VTBL_ENTRY int         ElemAllocNdx();
    VTBL_ENTRY void        ElemSet( int aIndex, ELEMENT_BASE* aBlock );
    VTBL_ENTRY ELEM_BASE*  ElemGet( int aIndex )

    /**
     * Function Value
     * fetches a project variable @a aVariable and returns true if that variable was
     * found, else false. If not found, aFetchedValue is not touched.  Any environment
     * variable is also a project variable.
     *
     * @param aVariable is the property or option to look for.
     * @param aFetchedValue is where to put the value of the property if it exists
     *  and aFetchedValue is not NULL.
     * @return bool - true if variable was found, else false.
     */
    VTBL_ENTRY bool Value( const wxString& aVariable, wxString* aFetchedValue = NULL );

    /**
     * Function Substitute
     * replaces any project variable references found within @a aString with their
     * values.  Any referenced variable is first sought in the PROJECT space, and if
     * not found, then sought in the environment.
     */
    VTBL_ENTRY const wxString Substitute( const wxString& aString );

    /**
     * Function SubstituteAndEvaluate
     * replaces any project variable references found within @a aString with their
     * values, and evaluates aString as an expression.
     * Any referenced variable is first sought in the PROJECT space, and if
     * not found, then sought in the environment.
     */
    VTBL_ENTRY const wxString SubstituteAndEvaluate( const wxString& aString );
#endif

#endif  // PROJECT_H_